<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<!-- saved from url=(0046)https://debrouxl.github.io/gcc4ti/gnuexts.html -->
<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>GNU C Language Extensions</title>
<style type="TEXT/CSS">
<!--
.IE3-DUMMY { CONT-SIZE: 100%; }
BODY { FONT-FAMILY: Verdana,Arial,Helvetica,Sans-Serif; BACKGROUND-COLOR: #E0E0E0; }
P { FONT-FAMILY: Verdana,Arial,Helvetica,Sans-Serif; }
H1 { FONT-FAMILY: Verdana,Arial,Helvetica,Sans-Serif; }
H2 { FONT-FAMILY: Verdana,Arial,Helvetica,Sans-Serif; }
H3 { FONT-FAMILY: Verdana,Arial,Helvetica,Sans-Serif; }
H4 { FONT-FAMILY: Verdana,Arial,Helvetica,Sans-Serif; }
H5 { FONT-FAMILY: Verdana,Arial,Helvetica,Sans-Serif; }
H6 { FONT-FAMILY: Verdana,Arial,Helvetica,Sans-Serif; }
UL { FONT-FAMILY: Verdana,Arial,Helvetica,Sans-Serif; }
TD { FONT-FAMILY: Verdana,Arial,Helvetica,Sans-Serif; BACKGROUND-COLOR: #FFFFFF; }
.NOBORDER { BACKGROUND-COLOR: #E0E0E0; PADDING: 0pt; }
.NOBORDER TD { FONT-FAMILY: Verdana,Arial,Helvetica,Sans-Serif; BACKGROUND-COLOR: #E0E0E0; PADDING: 0pt; }
.CODE { FONT-FAMILY: Courier New; }
-->
</style>
</head>
<body text="#000000" bgcolor="#E0E0E0">
<font size="5"><b>GNU C Language Extensions</b></font>
<hr>
<p>This part of the documentation is a modified version of the <a href="http://gcc.gnu.org/onlinedocs/gcc/C-Extensions.html">C Extensions</a> section of the <a href="http://gcc.gnu.org/onlinedocs/gcc/">GCC Manual</a>.
Therefore it is licensed under the <a href="https://debrouxl.github.io/gcc4ti/gnugpl.html#gnufdl">GNU Free Documentation License</a>.
<br><br>
GCC4TI (like all GNU C compilers) provides several language features not found
in ISO standard C.  To test for the availability of these
features in conditional compilation, check for a predefined macro
<code><a href="https://debrouxl.github.io/gcc4ti/cpp.html#SEC15_GNUC">__GNUC__</a></code>, which is always defined under GCC.
<br><br>
Some features that are in ISO C99 but not C89 are also, as
extensions, accepted by GCC in C89 mode.</p>

<ul>
<li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC63">Statements and Declarations in Expressions</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC64">Locally Declared Labels</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC65">Labels as Values</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC66">Nested Functions</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC67">Constructing Function Calls</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC69">Referring to a Type with 'typeof'</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC70">Generalized Lvalues</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC71">Conditionals with Omitted Operands</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC72">Double-Word Integers</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC73">Complex Numbers</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC74">Hex Floats</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC110">Binary Numbers</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC111">Structures With No Members</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC75">Arrays of Length Zero</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC76">Arrays of Variable Length</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC77">Macros with a Variable Number of Arguments</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC78">Non-Lvalue Arrays May Have Subscripts</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC79">Arithmetic on void and Function Pointers</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC80">Non-Constant Initializers</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC81">Compound Literals (Cast Constructors)</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC82">Designated Initializers</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC84">Cast to a Union Type</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC83">Case Ranges</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC85">Specifying Attributes of Functions</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC91">Specifying Attributes of Variables</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC92">Specifying Attributes of Types</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC85a">Attribute Syntax</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC86">Prototypes and Old-Style Function Definitions</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC87">C++ Style Comments</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC88">Dollar Signs in Identifier Names</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC89">Escape Character in Constants</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC90">Inquiring on Alignment of Types or Variables</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC93">Inline Functions</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC94_asm">Inline Assembler</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC96">Controlling Names Used in Assembler Code</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC97">Variables in Specified Registers</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC100">Alternate Keywords</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC101">Incomplete 'enum' Types</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC102">Function Names as Strings</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC103">Getting the Return or Frame Address of a Function</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC104">Other built-in functions provided by GCC</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC105">Slightly Looser Rules for Escaped Newlines</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC106">String Literals with Embedded Newlines</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC107">Mixed Declarations and Code</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC108">Unnamed struct/union Fields within structs/unions</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC109">Definite Access of Volatile Objects</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#history">History</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnugpl.html">GNU General Public License</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnugpl.html#gnufdl">GNU Free Documentation License</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnugpl.html#funding">Funding Free Software</a></b>
</li></ul>
<p>Original author: Free Software Foundation, Inc.
<br>
Authors of the modifications: Zeljko Juric, Sebastian Reichelt, and Kevin Kofler
<br>
Published by the TIGCC Team, and now the GCC4TI project.
<br>
See the <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#history">History</a> section for details and copyright information.
<br><br>
Permission is granted to copy, distribute and/or modify this document
under the terms of the <a href="https://debrouxl.github.io/gcc4ti/gnugpl.html#gnufdl">GNU Free Documentation License</a>, Version 1.1 or any
later version published by the Free Software Foundation; with the Invariant
Sections being "<a href="https://debrouxl.github.io/gcc4ti/gnugpl.html">GNU General Public License</a>" and "<a href="https://debrouxl.github.io/gcc4ti/gnugpl.html#funding">Funding Free Software</a>", the
Front-Cover texts being (a) (see below), and with the Back-Cover Texts being
(b) (see below).  A copy of the license is included in the section entitled
"<a href="https://debrouxl.github.io/gcc4ti/gnugpl.html#gnufdl">GNU Free Documentation License</a>".
<br><br>
(a) The FSF's Front-Cover Text is:
<br><br>
A GNU Manual
<br><br>
(b) The FSF's Back-Cover Text is:
<br><br>
You have freedom to copy and modify this GNU Manual, like GNU software.
Copies published by the Free Software Foundation raise funds for GNU
development.</p>

<hr>
<h2><a name="SEC63"><u>Statements and Declarations in Expressions</u></a></h2>
<p>A compound statement enclosed in parentheses may appear as an expression
in GNU C.  This allows you to use loops, switches, and local variables
within an expression.
<br><br>
Recall that a compound statement is a sequence of statements surrounded
by braces; in this construct, parentheses go around the braces.  For
example:</p>
<pre>({ int y = foo (); int z;
   if (y &gt; 0) z = y;
   else z = - y;
   z; })
</pre>
<p>is a valid (though slightly more complex than necessary) expression
for the absolute value of <code>foo&nbsp;()</code>.
<br><br>
The last thing in the compound statement should be an expression
followed by a semicolon; the value of this subexpression serves as the
value of the entire construct.  (If you use some other kind of statement
last within the braces, the construct has type <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#void">void</a></code>, and thus
effectively no value.)
<br><br>
This feature is especially useful in making macro definitions "safe" (so
that they evaluate each operand exactly once).  For example, the
"maximum" function is commonly defined as a macro in standard C as
follows:</p>
<pre>#define max(a,b) ((a) &gt; (b) ? (a) : (b))
</pre>
<p>But this definition computes either <i>a</i> or <i>b</i> twice, with bad
results if the operand has side effects.  In GNU C, if you know the
type of the operands (here let's assume <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#int">int</a></code>), you can define
the macro safely as follows:</p>
<pre>#define maxint(a,b) \
  ({int _a = (a), _b = (b); _a &gt; _b ? _a : _b; })
</pre>
<p>Embedded statements are not allowed in constant expressions, such as
the value of an enumeration constant, the width of a bit-field, or
the initial value of a static variable.
<br><br>
If you don't know the type of the operand, you can still do this, but you
must use <code><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC69">typeof</a></code>.</p>

<hr>
<h2><a name="SEC64"><u>Locally Declared Labels</u></a></h2>
<p>Each statement expression is a scope in which <u>local labels</u> can be
declared.  A local label is simply an identifier; you can jump to it
with an ordinary <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#goto">goto</a></code> statement, but only from within the
statement expression it belongs to.
<br><br>
A local label declaration looks like this:</p>
<pre>__label__ <i>label</i>;
</pre>
<p>or</p>
<pre>__label__ <i>label1</i>, <i>label2</i>, /* ... */;
</pre>
<p>Local label declarations must come at the beginning of the statement
expression, right after the <code>({</code>, before any ordinary
declarations.
<br><br>
The label declaration defines the label <i>name</i>, but does not define
the label itself.  You must do this in the usual way, with
<code><i>label</i>:</code>, within the statements of the statement expression.
<br><br>
The local label feature is useful because statement expressions are
often used in macros.  If the macro contains nested loops, a <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#goto">goto</a></code>
can be useful for breaking out of them.  However, an ordinary label
whose scope is the whole function cannot be used: if the macro can be
expanded several times in one function, the label will be multiply
defined in that function.  A local label avoids this problem.  For
example:</p>
<pre>#define SEARCH(array, target)                     \
({                                                \
  __label__ found;                                \
  typeof (target) _SEARCH_target = (target);      \
  typeof (*(array)) *_SEARCH_array = (array);     \
  int i, j;                                       \
  int value;                                      \
  for (i = 0; i &lt; max; i++)                       \
    for (j = 0; j &lt; max; j++)                     \
      if (_SEARCH_array[i][j] == _SEARCH_target)  \
        { value = i; goto found; }                \
  value = -1;                                     \
 found:                                           \
  value;                                          \
})
</pre>

<hr>
<h2><a name="SEC65"><u>Labels as Values</u></a></h2>
<p>You can get the address of a label defined in the current function
(or a containing function) with the unary operator <code>&amp;&amp;</code>.  The
+ value has type <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#void">void</a>*</code>.  This value is a constant and can be used
wherever a constant of that type is valid.  For example:</p>
<pre>void *ptr;
/* ... */
ptr = &amp;&amp;foo;
</pre>
<p>To use these values, you need to be able to jump to one.  This is done
with the computed goto statement, <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#goto">goto</a>&nbsp;*<i>exp</i>;</code>.  For example,</p>
<pre>goto *ptr;
</pre>
<p>Any expression of type <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#void">void</a>*</code> is allowed.
<br><br>
One way of using these constants is in initializing a static array that
will serve as a jump table:</p>
<pre>static void *array[] = { &amp;&amp;foo, &amp;&amp;bar, &amp;&amp;hack };
</pre>
<p>Then you can select a label with indexing, like this:</p>
<pre>goto *array[i];
</pre>
<p>Note that this does not check whether the subscript is in bounds - array
indexing in C never does that.
<br><br>
Such an array of label values serves a purpose much like that of the
<code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#switch">switch</a></code> statement.  The <code>switch</code> statement is cleaner, so
use that rather than an array unless the problem does not fit a
<code>switch</code> statement very well.
<br><br>
You may not use this mechanism to jump to code in a different function.
If you do that, totally unpredictable things will happen.  The best way to
avoid this is to store the label address only in automatic variables and
never pass it as an argument.
<br><br>
An alternate way to write the above example is</p>
<pre>static const int array[] = { &amp;&amp;foo - &amp;&amp;foo, &amp;&amp;bar - &amp;&amp;foo,
                             &amp;&amp;hack - &amp;&amp;foo };
goto *(&amp;&amp;foo + array[i]);
</pre>
<p>This is more friendly to code living in shared libraries (DLLs), as it reduces
the number of dynamic relocations that are needed (and, by consequence,
would allow the data to be read-only).</p>

<hr>
<h2><a name="SEC66"><u>Nested Functions</u></a></h2>
<p>A <u>nested function</u> is a function defined inside another function.
The nested function's
name is local to the block where it is defined.  For example, here we
define a nested function named <code>square</code>, and call it twice:</p>
<pre>double square_sum (double a, double b)
{
  double square (double z)
  {
    return z * z;
  }

  return square (a) + square (b);
}
</pre>
<p>The nested function can access all the variables of the containing
function that are visible at the point of its definition.  This is
called <u>lexical scoping</u>.  For example, here we show a nested
function which uses an inherited variable named <code>offset</code>:</p>
<pre>int foo (int *array, int offset, int size)
{
  int access (int *array, int index)
  {
    return array[index + offset];
  }

  int i;
  /* ... */
  for (i = 0; i &lt; size; i++)
    /* ... */ access (array, i) /* ... */
}
</pre>
<p>Nested function definitions are permitted within functions in the places
where variable definitions are allowed; that is, in any block, before
the first statement in the block.
<br><br>
It is possible to call the nested function from outside the scope of its
name by storing its address or passing the address to another function:</p>
<pre>int hack (int *array, int size)
{
  void store (int index, int value)
  {
    array[index] = value;
  }

  intermediate (store, size);
}
</pre>
<p>Here, the function <code>intermediate</code> receives the address of
<code>store</code> as an argument.  If <code>intermediate</code> calls <code>store</code>,
the arguments given to <code>store</code> are used to store into <code>array</code>.
But this technique works only so long as the containing function
(<code>hack</code>, in this example) does not exit.
<br><br>
If you try to call the nested function through its address after the
containing function has exited, all hell will break loose.  If you try
to call it after a containing scope level has exited, and if it refers
to some of the variables that are no longer in scope, you may be lucky,
but it's not wise to take the risk.  If, however, the nested function
does not refer to anything that has gone out of scope, you should be
safe.
<br><br>
GCC implements taking the address of a nested function using a technique
called <u>trampolines</u>.  A paper describing them is available at
<a href="http://people.debian.org/~aaronl/Usenix88-lexic.pdf">http://people.debian.org/~aaronl/Usenix88-lexic.pdf</a>.
Note that trampolines are currently broken in GCC4TI; they create code on the
stack, which can make HW2 calculators crash.
<br><br>
A nested function can jump to a label inherited from a containing
function, provided the label was explicitly declared in the containing
function (see <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC64">Local Labels</a>).  Such a jump returns instantly to the
containing function, exiting the nested function which did the
<code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#goto">goto</a></code> and any intermediate functions as well.  Here is an example:</p>
<pre>int bar (int *array, int offset, int size)
{
  __label__ failure;
  int access (int *array, int index)
    {
      if (index &gt; size)
        goto failure;
      return array[index + offset];
    }
  int i;
  /* ... */
  for (i = 0; i &lt; size; i++)
    /* ... */ access (array, i) /* ... */
  /* ... */
  return 0;

 /* Control comes here from 'access'
    if it detects an error.  */
 failure:
  return -1;
}
</pre>
<p>A nested function always has internal linkage.  Declaring one with
<code>extern</code> is erroneous.  If you need to declare the nested function
before its definition, use <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#auto">auto</a></code> (which is otherwise meaningless
for function declarations).</p>
<pre>int bar (int *array, int offset, int size)
{
  __label__ failure;
  auto int access (int *, int);
  /* ... */
  int access (int *array, int index)
    {
      if (index &gt; size)
        goto failure;
      return array[index + offset];
    }
  /* ... */
}
</pre>

<hr>
<h2><a name="SEC67"><u>Constructing Function Calls</u></a></h2>
<p>Using the built-in functions described below, you can record
the arguments a function received, and call another function
with the same arguments, without knowing the number or types
of the arguments.
<br><br>
You can also record the return value of that function call,
and later return that value, without knowing what data type
the function tried to return (as long as your caller expects
that data type).</p>

<ul>
<li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC67___builtin_apply_args">__builtin_apply_args</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC67___builtin_apply">__builtin_apply</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC67___builtin_return">__builtin_return</a></b>
</li></ul>
<h3><a name="SEC67___builtin_apply_args"><u>__builtin_apply_args</u></a></h3>
<p><code><b><a href="https://debrouxl.github.io/gcc4ti/keywords.html#void">void</a></b> *__builtin_apply_args (<b><a href="https://debrouxl.github.io/gcc4ti/keywords.html#void">void</a></b>);</code>
<br><br>
This built-in function returns a pointer to data
describing how to perform a call with the same arguments as were passed
to the current function.
<br><br>
The function saves the arg pointer register, structure value address,
and all registers that might be used to pass arguments to a function
into a block of memory allocated on the stack.  Then it returns the
address of that block.</p>

<h3><a name="SEC67___builtin_apply"><u>__builtin_apply</u></a></h3>
<p><code><b><a href="https://debrouxl.github.io/gcc4ti/keywords.html#void">void</a></b> *__builtin_apply (<b><a href="https://debrouxl.github.io/gcc4ti/keywords.html#void">void</a></b> (*fnc)(), <b><a href="https://debrouxl.github.io/gcc4ti/keywords.html#void">void</a></b> *args, <b><a href="https://debrouxl.github.io/gcc4ti/keywords.html#int">int</a></b> size);</code>
<br><br>
This built-in function invokes <i>function</i>
with a copy of the parameters described by <i>arguments</i>
and <i>size</i>.
<br><br>
The value of <i>arguments</i> should be the value returned by
<a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC67___builtin_apply_args">__builtin_apply_args</a>.
The argument <i>size</i> specifies the size
of the stack argument data, in bytes.
<br><br>
This function returns a pointer to data describing
how to return whatever value was returned by <i>function</i>.  The data
is saved in a block of memory allocated on the stack.
<br><br>
It is not always simple to compute the proper value for <i>size</i>.  The
value is used by __builtin_apply to compute the amount of data
that should be pushed on the stack and copied from the incoming argument
area.</p>

<h3><a name="SEC67___builtin_return"><u>__builtin_return</u></a></h3>
<p><code><b><a href="https://debrouxl.github.io/gcc4ti/keywords.html#void">void</a></b> __builtin_return (<b><a href="https://debrouxl.github.io/gcc4ti/keywords.html#void">void</a></b> *result);</code>
<br><br>
This built-in function returns the value described by <i>result</i> from
the containing function.  You should specify, for <i>result</i>, a value
returned by <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC67___builtin_apply">__builtin_apply</a>.</p>

<hr>
<h2><a name="SEC69"><u>Referring to a Type with 'typeof'</u></a></h2>
<p>Another way to refer to the type of an expression is with <code>typeof</code>.
The syntax of using of this keyword looks like <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#sizeof">sizeof</a></code>, but the
construct acts semantically like a type name defined with <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#typedef">typedef</a></code>.
<br><br>
There are two ways of writing the argument to <code>typeof</code>: with an
expression or with a type.  Here is an example with an expression:</p>
<pre>typeof (x[0](1))
</pre>
<p>This assumes that <i>x</i> is an array of pointers to functions;
the type described is that of the values of the functions.
<br><br>
Here is an example with a typename as the argument:</p>
<pre>typeof (int *)
</pre>
<p>Here the type described is that of pointers to <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#int">int</a></code>.
<br><br>
An alternate keyword for <code>typeof</code> is <code>__typeof__</code>.
See <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC100">Alternate Keywords</a>.
<br><br>
A <code>typeof</code>-construct can be used anywhere a typedef name could be
used.  For example, you can use it in a declaration, in a cast, or inside
of <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#sizeof">sizeof</a></code> or <code>typeof</code>.
<br><br>
<code>typeof</code> is often useful in conjunction with the
statements-within-expressions feature.  Here is how the two together can
be used to define a safe "maximum" macro that operates on any
arithmetic type and evaluates each of its arguments exactly once:</p>
<pre>#define max(a,b) \
  ({ typeof (a) _a = (a); \
      typeof (b) _b = (b); \
    _a &gt; _b ? _a : _b; })
</pre>
<p>The reason for using names that start with underscores for the local
variables is to avoid conflicts with variable names that occur within the
expressions that are substituted for <code>a</code> and <code>b</code>.  Eventually we
hope to design a new form of declaration syntax that allows you to declare
variables whose scopes start only after their initializers; this will be a
more reliable way to prevent such conflicts.
<br><br>
Some more examples of the use of <code>typeof</code>:</p>
<ul>
<li><p>This declares <i>y</i> with the type of what <i>x</i> points to.</p>
<pre>typeof (*x) y;
</pre>

</li>
<li><p>This declares <i>y</i> as an array of such values.</p>
<pre>typeof (*x) y[4];
</pre>

</li>
<li><p>This declares <i>y</i> as an array of pointers to characters:</p>
<pre>typeof (typeof (char *)[4]) y;
</pre>
<p>It is equivalent to the following traditional C declaration:</p>
<pre>char *y[4];
</pre>
<p>To see the meaning of the declaration using <code>typeof</code>, and why it
might be a useful way to write, let's rewrite it with these macros:</p>
<pre>#define pointer(T) typeof(T *)
#define array(T, N) typeof(T [N])
</pre>
<p>Now the declaration can be rewritten this way:</p>
<pre>array (pointer (char), 4) y;
</pre>
<p>Thus, <code>array&nbsp;(pointer&nbsp;(char),&nbsp;4)</code> is the type of arrays of 4
pointers to <code>char</code>.</p></li>
</ul>
<p><i>Compatibility Note:</i> In addition to <code>typeof</code>, GCC 2 supported
a more limited extension which permitted one to write</p>
<pre>typedef <i>T</i> = <i>expr</i>;
</pre>
<p>with the effect of declaring <i>T</i> to have the type of the expression
<i>expr</i>.  This extension does not work with GCC 3 (versions between
3.0 and 3.2 will crash; 3.2.1 and later give an error).  Code which
relies on it should be rewritten to use <code>typeof</code>:</p>
<pre>typedef typeof(<i>expr</i>) <i>T</i>;
</pre>
<p>This will work with all versions of GCC.</p>

<hr>
<h2><a name="SEC70"><u>Generalized Lvalues</u></a></h2>
<p>Compound expressions, conditional expressions and casts are allowed as
lvalues provided their operands are lvalues.  This means that you can take
their addresses or store values into them.
<br><br>
For example, a compound expression can be assigned, provided the last
expression in the sequence is an lvalue.  These two expressions are
equivalent:</p>
<pre>(a, b) += 5
a, (b += 5)
</pre>
<p>Similarly, the address of the compound expression can be taken.  These two
expressions are equivalent:</p>
<pre>&amp;(a, b)
a, &amp;b
</pre>
<p>A conditional expression is a valid lvalue if its type is not void and the
true and false branches are both valid lvalues.  For example, these two
expressions are equivalent:</p>
<pre>(a ? b : c) = 5
(a ? b = 5 : (c = 5))
</pre>
<p>A cast is a valid lvalue if its operand is an lvalue.  A simple
assignment whose left-hand side is a cast works by converting the
right-hand side first to the specified type, then to the type of the
inner left-hand side expression.  After this is stored, the value is
converted back to the specified type to become the value of the
assignment.  Thus, if <code>a</code> has type <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#int">char</a>*</code>, the following two
expressions are equivalent:</p>
<pre>(int)a = 5
(int)(a = (char *)(int)5)
</pre>
<p>An assignment-with-arithmetic operation such as <code>+=</code> applied to a cast
performs the arithmetic using the type resulting from the cast, and then
continues as in the previous case.  Therefore, these two expressions are
equivalent:</p>
<pre>(int)a += 5
(int)(a = (char *)(int) ((int)a + 5))
</pre>
<p>You cannot take the address of an lvalue cast, because the use of its
address would not work out coherently.  Suppose that <code>&amp;(int)f</code> were
permitted, where <code>f</code> has type <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#float">float</a></code>.  Then the following
statement would try to store an integer bit-pattern where a floating
point number belongs:</p>
<pre>*&amp;(int)f = 1;
</pre>
<p>This is quite different from what <code>(int)f&nbsp;=&nbsp;1</code> would do - that
would convert 1 to floating point and store it.  Rather than cause this
inconsistency, the GNU team thinks it is better to prohibit use of <code>&amp;</code> on a cast.
<br><br>
If you really do want an <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#int">int</a>*</code> pointer with the address of
<code>f</code>, you can simply write <code>(int*)&amp;f</code>.</p>

<hr>
<h2><a name="SEC71"><u>Conditionals with Omitted Operands</u></a></h2>
<p>The middle operand in a conditional expression may be omitted.  Then
if the first operand is nonzero, its value is the value of the conditional
expression.
<br><br>
Therefore, the expression</p>
<pre>x ? : y
</pre>
<p>has the value of <code>x</code> if that is nonzero; otherwise, the value of
<code>y</code>.
<br><br>
This example is perfectly equivalent to</p>
<pre>x ? x : y
</pre>
<p>In this simple case, the ability to omit the middle operand is not
especially useful.  When it becomes useful is when the first operand does,
or may (if it is a macro argument), contain a side effect.  Then repeating
the operand in the middle would perform the side effect twice.  Omitting
the middle operand uses the value already computed without the undesirable
effects of recomputing it.</p>

<hr>
<h2><a name="SEC72"><u>Double-Word Integers</u></a></h2>
<p>ISO C99 supports data types for integers that are at least 64 bits wide,
and as an extension GCC supports them in C89 mode.
Simply write <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#short">long</a>&nbsp;<a href="https://debrouxl.github.io/gcc4ti/keywords.html#short">long</a>&nbsp;<a href="https://debrouxl.github.io/gcc4ti/keywords.html#int">int</a></code> for a signed integer, or
<code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#short">unsigned</a>&nbsp;<a href="https://debrouxl.github.io/gcc4ti/keywords.html#short">long</a>&nbsp;<a href="https://debrouxl.github.io/gcc4ti/keywords.html#short">long</a>&nbsp;<a href="https://debrouxl.github.io/gcc4ti/keywords.html#int">int</a></code> for an unsigned integer.  To make an
integer constant of type <code>long&nbsp;long&nbsp;int</code>, add the suffix <code>LL</code>
to the integer.  To make an integer constant of type <code>unsigned&nbsp;long
long&nbsp;int</code>, add the suffix <code>ULL</code> to the integer.
<br><br>
You can use these types in arithmetic like any other integer types.
Addition, subtraction, and bitwise boolean operations on these types
are open-coded on all types of machines, as well as shifts with a constant
value.  Multiplication, division and shifts are not open-coded and use
special library routines.
<br><br>
There may be pitfalls when you use <code>long&nbsp;long</code> types for function
arguments, unless you declare function prototypes.  If a function
expects type <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#int">int</a></code> for its argument, and you pass a value of type
<code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#short">long</a>&nbsp;<a href="https://debrouxl.github.io/gcc4ti/keywords.html#short">long</a>&nbsp;<a href="https://debrouxl.github.io/gcc4ti/keywords.html#int">int</a></code>, confusion will result because the caller and the
subroutine will disagree about the number of bytes for the argument.
Likewise, if the function expects <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#short">long</a>&nbsp;<a href="https://debrouxl.github.io/gcc4ti/keywords.html#short">long</a>&nbsp;<a href="https://debrouxl.github.io/gcc4ti/keywords.html#int">int</a></code> and you pass
<code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#int">int</a></code>.  The best way to avoid such problems is to use prototypes.</p>

<hr>
<h2><a name="SEC73"><u>Complex Numbers</u></a></h2>
<p>ISO C99 supports complex floating data types, and as an extension GCC
supports them in C89 mode, and supports complex integer data
types which are not part of ISO C99.  You can declare complex types
using the keyword <code>_Complex</code>.  As an extension, the older GNU
keyword <code>__complex__</code> is also supported.
<br><br>
For example, <code>_Complex&nbsp;double&nbsp;x;</code> declares <code>x</code> as a
variable whose real part and imaginary part are both of type
<code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#float">double</a></code>.  <code>_Complex&nbsp;short&nbsp;int&nbsp;y;</code> declares <code>y</code> to
have real and imaginary parts of type <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#short">short</a>&nbsp;<a href="https://debrouxl.github.io/gcc4ti/keywords.html#int">int</a></code>; this is not
likely to be useful, but it shows that the set of complex types is
complete.
<br><br>
To write a constant with a complex data type, use the suffix <code>i</code> or
<code>j</code> (either one; they are equivalent).  For example, <code>2.5fi</code>
has type <code>_Complex&nbsp;float</code> and <code>3i</code> has type
<code>_Complex&nbsp;int</code>.  Such a constant always has a pure imaginary
value, but you can form any complex value you like by adding one to a
real constant.  This is a GNU extension; once GCC4TI supports this, you should include <code>&lt;complex.h&gt;</code> and
use the macros <code>I</code> or <code>_Complex_I</code> instead.
<br><br>
To extract the real part of a complex-valued expression <i>exp</i>, write
<code>__real__&nbsp;<i>exp</i></code>.  Likewise, use <code>__imag__</code> to
extract the imaginary part.  This is a GNU extension; for values of
floating type, you should use the ISO C99 functions <code>crealf</code>,
<code>creal</code>, <code>creall</code>, <code>cimagf</code>, <code>cimag</code> and
<code>cimagl</code>, declared in <code>&lt;complex.h&gt;</code> (not yet available in GCC4TI) and also provided as
built-in functions by GCC.
<br><br>
The operator <code>~</code> performs complex conjugation when used on a value
with a complex type.  This is a GNU extension; for values of
floating type, you should use the ISO C99 functions <code>conjf</code>,
<code>conj</code> and <code>conjl</code>, declared in <code>&lt;complex.h&gt;</code> and also
provided as built-in functions by GCC.
<br><br>
GCC can allocate complex automatic variables in a noncontiguous
fashion; it's even possible for the real part to be in a register while
the imaginary part is on the stack (or vice-versa).</p>

<hr>
<h2><a name="SEC74"><u>Hex Floats</u></a></h2>
<p>ISO C99 supports floating-point numbers written not only in the usual
decimal notation, such as <code>1.55e1</code>, but also numbers such as
<code>0x1.fp3</code> written in hexadecimal format.  As a GNU extension, GCC
supports this in C89 mode (except in some cases when strictly
conforming).  In that format the
<code>0x</code> hex introducer and the <code>p</code> or <code>P</code> exponent field are
mandatory.  The exponent is a decimal number that indicates the power of
2 by which the significant part will be multiplied.  Thus <code>0x1.f</code> is
<code>1&nbsp;15/16</code>,
<code>p3</code> multiplies it by 8, and the value of <code>0x1.fp3</code>
is the same as <code>1.55e1</code>.
<br><br>
Unlike for floating-point numbers in the decimal notation the exponent
is always required in the hexadecimal notation.  Otherwise the compiler
would not be able to resolve the ambiguity of, e.g., <code>0x1.f</code>.  This
could mean <code>1.0f</code> or <code>1.9375</code> since <code>f</code> is also the
extension for floating-point constants of type <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#float">float</a></code>.</p>

<hr>
<h2><a name="SEC110"><u>Binary Numbers</u></a></h2>
<p>GCC4TI allows you to specify binary numbers by using a <code>0b</code> prefix.  This can be handy
in many occasions, such as when trying to declare sprites in a way which actually allows you to see
the picture.  For example, the following declaration defines a simple black and white 8x8 diagonal
cross:</p>
<pre>unsigned char cross[8] =
 {0b10000001,
  0b01000010,
  0b00100100,
  0b00011000,
  0b00011000,
  0b00100100,
  0b01000010,
  0b10000001};
</pre>

<hr>
<h2><a name="SEC111"><u>Structures With No Members</u></a></h2>
<p>GCC permits a C structure to have no members:</p>
<pre>struct empty {
};
</pre>
<p>The structure will have size zero.  In C++, empty structures are part
of the language, and the language standard says they have size 1.</p>

<hr>
<h2><a name="SEC75"><u>Arrays of Length Zero</u></a></h2>
<p>Zero-length arrays are allowed in GNU C.  They are very useful as the
last element of a structure which is really a header for a variable-length
object:</p>
<pre>struct line {
  int length;
  char contents[0];
};

struct line *thisline = (struct line *)
  malloc (sizeof (struct line) + this_length);
thisline-&gt;length = this_length;
</pre>
<p>In ISO C90, you would have to give <i>contents</i> a length of 1, which
means either you waste space or complicate the argument to <a href="https://debrouxl.github.io/gcc4ti/alloc.html#malloc">malloc</a>.
<br><br>
In ISO C99, you would use a <u>flexible array member</u>, which is
slightly different in syntax and semantics:</p>
<ul>
<li><p>Flexible array members are written as <code>contents[]</code> without
the <code>0</code>.
</p></li>
<li><p>Flexible array members have incomplete type, and so the <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#sizeof">sizeof</a></code>
operator may not be applied.  As a quirk of the original implementation
of zero-length arrays, <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#sizeof">sizeof</a></code> evaluates to zero.
</p></li>
<li><p>Flexible array members may only appear as the last member of a
<code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#struct">struct</a></code> that is otherwise non-empty.
</p></li>
<li><p>A structure containing a flexible array member, or a union containing
such a structure (possibly recursively), may not be a member of a
structure or an element of an array.  (However, these uses are
permitted by GCC as extensions.)</p></li>
</ul>
<p>GCC versions before 3.0 allowed zero-length arrays to be statically
initialized, as if they were flexible arrays.  In addition to those
cases that were useful, it also allowed initializations in situations
that would corrupt later data.  Non-empty initialization of zero-length
arrays is now treated like any case where there are more initializer
elements than the array holds, in that a suitable warning about "excess
elements in array" is given, and the excess elements (all of them, in
this case) are ignored.
<br><br>
Instead GCC allows static initialization of flexible array members.
This is equivalent to defining a new structure containing the original
structure followed by an array of sufficient size to contain the data.
I.e. in the following, <i>f1</i> is constructed as if it were declared
like <i>f2</i>.</p>
<pre>struct f1 {
  int x; int y[];
} f1 = { 1, { 2, 3, 4 } };

struct f2 {
  struct f1 f1; int data[3];
} f2 = { { 1 }, { 2, 3, 4 } };
</pre>
<p>The convenience of this extension is that <i>f1</i> has the desired
type, eliminating the need to consistently refer to <i>f2</i>.<i>f1</i>.
<br><br>
This has symmetry with normal static arrays, in that an array of
unknown size is also written with <code>[]</code>.
<br><br>
Of course, this extension only makes sense if the extra data comes at
the end of a top-level object, as otherwise we would be overwriting
data at subsequent offsets.  To avoid undue complication and confusion
with initialization of deeply nested arrays, we simply disallow any
non-empty initialization except when the structure is the top-level
object.  For example:</p>
<pre>struct foo { int x; int y[]; };
struct bar { struct foo z; };

struct foo a = { 1, { 2, 3, 4 } };        // Valid.
struct bar b = { { 1, { 2, 3, 4 } } };    // Invalid.
struct bar c = { { 1, { } } };            // Valid.
struct foo d[1] = { { 1, { 2, 3, 4 } } }; // Invalid.
</pre>

<hr>
<h2><a name="SEC76"><u>Arrays of Variable Length</u></a></h2>
<p>Variable-length automatic arrays are allowed in ISO C99, and as an
extension GCC accepts them in C89 mode.  (However, GCC's
implementation of variable-length arrays does not yet conform in detail
to the ISO C99 standard.)  These arrays are
declared like any other automatic arrays, but with a length that is not
a constant expression.  The storage is allocated at the point of
declaration and deallocated when the brace-level is exited.  For
example:</p>
<pre>FILE *concat_fopen (const char *s1, const char *s2, const char *mode)
{
  char str[strlen (s1) + strlen (s2) + 1];
  strcpy (str, s1);
  strcat (str, s2);
  return fopen (str, mode);
}
</pre>
<p>Jumping or breaking out of the scope of the array name deallocates the
storage.  Jumping into the scope is not allowed; you get an error
message for it.
<br><br>
You can use the function <a href="https://debrouxl.github.io/gcc4ti/alloc.html#alloca">alloca</a> to get an effect much like
variable-length arrays.  The function <a href="https://debrouxl.github.io/gcc4ti/alloc.html#alloca">alloca</a> is available in
many other C implementations (but not in all).  On the other hand,
variable-length arrays are more elegant.
<br><br>
There are other differences between these two methods.  Space allocated
with <a href="https://debrouxl.github.io/gcc4ti/alloc.html#alloca">alloca</a> exists until the containing <i>function</i> returns.
The space for a variable-length array is deallocated as soon as the array
name's scope ends.  (If you use both variable-length arrays and
<a href="https://debrouxl.github.io/gcc4ti/alloc.html#alloca">alloca</a> in the same function, deallocation of a variable-length array
will also deallocate anything more recently allocated with <a href="https://debrouxl.github.io/gcc4ti/alloc.html#alloca">alloca</a>.)
<br><br>
You can also use variable-length arrays as arguments to functions:</p>
<pre>struct entry
tester (int len, char data[len][len])
{
  /* ... */
}
</pre>
<p>The length of an array is computed once when the storage is allocated
and is remembered for the scope of the array in case you access it with
<code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#sizeof">sizeof</a></code>.
<br><br>
If you want to pass the array first and the length afterward, you can
use a forward declaration in the parameter list - another GNU extension.</p>
<pre>struct entry
tester (int len; char data[len][len], int len)
{
  /* ... */
}
</pre>
<p>The <code>int&nbsp;len</code> before the semicolon is a <u>parameter forward
declaration</u>, and it serves the purpose of making the name <i>len</i>
known when the declaration of <i>data</i> is parsed.
<br><br>
You can write any number of such parameter forward declarations in the
parameter list.  They can be separated by commas or semicolons, but the
last one must end with a semicolon, which is followed by the "real"
parameter declarations.  Each forward declaration must match a "real"
declaration in parameter name and data type.  ISO C99 does not support
parameter forward declarations.</p>

<hr>
<h2><a name="SEC77"><u>Macros with a Variable Number of Arguments</u></a></h2>
<p>In the ISO C standard of 1999, a macro can be declared to accept a
variable number of arguments much as a function can.  The syntax for
defining the macro is similar to that of a function.  Here is an
example:</p>
<pre>#define lprintf(format, ...) fprintf (log, format, __VA_ARGS__)
</pre>
<p>Here <code>...</code> is a <u>variable argument</u>.  In the invocation of
such a macro, it represents the zero or more tokens until the closing
parenthesis that ends the invocation, including any commas.  This set of
tokens replaces the identifier <code>__VA_ARGS__</code> in the macro body
wherever it appears.
For more information, see <a href="https://debrouxl.github.io/gcc4ti/cpp.html#SEC13">Variadic Macros</a>.
<br><br>
GCC has long supported variadic macros, and used a different syntax that
allowed you to give a name to the variable arguments just like any other
argument.  Here is an example:</p>
<pre>#define lprintf(format, args...) fprintf (stderr, format, args)
</pre>
<p>This is in all ways equivalent to the ISO C example above, but arguably
more readable and descriptive.
<br><br>
GNU CPP has two further variadic macro extensions, and permits them to
be used with either of the above forms of macro definition.
<br><br>
In standard C, you are not allowed to leave the variable argument out
entirely; but you are allowed to pass an empty argument.  For example,
this invocation is invalid in ISO C, because there is no comma after
the string:</p>
<pre>lprintf ("A message");
</pre>
<p>GNU CPP permits you to completely omit the variable arguments in this
way.  In the above examples, the compiler would complain, though since
the expansion of the macro still has the extra comma after the format
string.
<br><br>
To help solve this problem, CPP behaves specially for variable arguments
used with the token paste operator, <code>##</code>.  If instead you write</p>
<pre>#define lprintf(format, ...) fprintf (log, format, ## __VA_ARGS__)
</pre>
<p>and if the variable arguments are omitted or empty, the <code>##</code>
operator causes the preprocessor to remove the comma before it.  If you
do provide some variable arguments in your macro invocation, GNU CPP
does not complain about the paste operation and instead places the
variable arguments after the comma.  Just like any other pasted macro
argument, these arguments are not macro expanded.</p>

<hr>
<h2><a name="SEC78"><u>Non-Lvalue Arrays May Have Subscripts</u></a></h2>
<p>In ISO C99, arrays that are not lvalues still decay to pointers, and
may be subscripted, although they may not be modified or used after
the next sequence point and the unary <code>&amp;</code> operator may not be
applied to them.  As an extension, GCC allows such arrays to be
subscripted in C89 mode, though otherwise they do not decay to
pointers outside C99 mode.  For example,
this is valid in GNU C though not valid in C89:</p>
<pre>struct foo {int a[4];};

struct foo f();

bar (int index)
{
  return f().a[index];
}
</pre>

<hr>
<h2><a name="SEC79"><u>Arithmetic on void and Function Pointers</u></a></h2>
<p>In GNU C, addition and subtraction operations are supported on pointers to
<code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#void">void</a></code> and on pointers to functions.  This is done by treating the
size of a <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#void">void</a></code> or of a function as 1.
<br><br>
A consequence of this is that <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#sizeof">sizeof</a></code> is also allowed on <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#void">void</a></code>
and on function types, and returns 1.
<br><br>
The option <b>'-Wpointer-arith'</b> requests a warning if these extensions
are used.</p>

<hr>
<h2><a name="SEC80"><u>Non-Constant Initializers</u></a></h2>
<p>As in standard C++ and ISO C99, the elements of an aggregate initializer for an
automatic variable are not required to be constant expressions in GNU C.
Here is an example of an initializer with run-time varying elements:</p>
<pre>void foo (float f, float g)
{
  float beat_freqs[2] = { f-g, f+g };
  /* ... */
}
</pre>

<hr>
<h2><a name="SEC81"><u>Compound Literals (Cast Constructors)</u></a></h2>
<p>ISO C99 supports compound literals.  A compound literal looks like
a cast containing an initializer.  Its value is an object of the
type specified in the cast, containing the elements specified in
the initializer; it is an lvalue.  As an extension, GCC supports
compound literals in C89 mode and in C++.
<br><br>
Usually, the specified type is a structure.  Assume that
<code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#struct">struct</a>&nbsp;foo</code> and <i>structure</i> are declared as shown:</p>
<pre>struct foo {int a; char b[2];} structure;
</pre>
<p>Here is an example of constructing a <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#struct">struct</a>&nbsp;foo</code> with a compound literal:</p>
<pre>structure = ((struct foo) {x + y, 'a', 0});
</pre>
<p>This is equivalent to writing the following:</p>
<pre>{
  struct foo temp = {x + y, 'a', 0};
  structure = temp;
}
</pre>
<p>You can also construct an array.  If all the elements of the compound literal
are (made up of) simple constant expressions, suitable for use in
initializers of objects of static storage duration, then the compound
literal can be coerced to a pointer to its first element and used in
such an initializer, as shown here:</p>
<pre>char **foo = (char *[]) { "x", "y", "z" };
</pre>
<p>Compound literals for scalar types and union types are
also allowed, but then the compound literal is equivalent
to a cast.
<br><br>
As a GNU extension, GCC allows initialization of objects with static storage
duration by compound literals (which is not possible in ISO C99, because
the initializer is not a constant).
It is handled as if the object was initialized only with the bracket
enclosed list if compound literal's and object types match.
The initializer list of the compound literal must be constant.
If the object being initialized has array type of unknown size, the size is
determined by compound literal size.</p>
<pre>static struct foo x = (struct foo) {1, 'a', 'b'};
static int y[] = (int []) {1, 2, 3};
static int z[] = (int [3]) {1};
</pre>
<p>The above lines are equivalent to the following:</p>
<pre>static struct foo x = {1, 'a', 'b'};
static int y[] = {1, 2, 3};
static int z[] = {1, 0, 0};
</pre>

<hr>
<h2><a name="SEC82"><u>Designated Initializers</u></a></h2>
<p>Standard C89 requires the elements of an initializer to appear in a fixed
order, the same as the order of the elements in the array or structure
being initialized.
<br><br>
In ISO C99 you can give the elements in any order, specifying the array
indices or structure field names they apply to, and GNU C allows this as
an extension in C89 mode as well.
<br><br>
To specify an array index, write
<code>[<i>index</i>]&nbsp;=</code> before the element value.  For example,</p>
<pre>int a[6] = { [4] = 29, [2] = 15 };
</pre>
<p>is equivalent to</p>
<pre>int a[6] = { 0, 0, 15, 0, 29, 0 };
</pre>
<p>The index values must be constant expressions, even if the array being
initialized is automatic.
<br><br>
An alternative syntax for this which has been obsolete since GCC 2.5 but
GCC still accepts is to write <code>[<i>index</i>]</code> before the element
value, with no <code>=</code>.
<br><br>
To initialize a range of elements to the same value, write
<code>[<i>first</i>&nbsp;...&nbsp;<i>last</i>]&nbsp;=&nbsp;<i>value</i></code>.  This is a GNU
extension.  For example,</p>
<pre>int widths[] = { [0 ... 9] = 1, [10 ... 99] = 2, [100] = 3 };
</pre>
<p>If the value in it has side-effects, the side-effects will happen only once,
not for each initialized field by the range initializer.
<br><br>
Note that the length of the array is the highest value specified
plus one.
<br><br>
In a structure initializer, specify the name of a field to initialize
with <code>.<i>fieldname</i>&nbsp;=</code> before the element value.  For example,
given the following structure,</p>
<pre>struct point { int x, y; };
</pre>
<p>the following initialization</p>
<pre>struct point p = { .y = yvalue, .x = xvalue };
</pre>
<p>is equivalent to</p>
<pre>struct point p = { xvalue, yvalue };
</pre>
<p>Another syntax which has the same meaning, obsolete since GCC 2.5, is
<code><i>fieldname</i>:</code>, as shown here:</p>
<pre>struct point p = { y: yvalue, x: xvalue };
</pre>
<p>The <code>[<i>index</i>]</code> or <code>.<i>fieldname</i></code> is known as a
<u>designator</u>.  You can also use a designator (or the obsolete colon
syntax) when initializing a union, to specify which element of the union
should be used.  For example,</p>
<pre>union foo { int i; double d; };

union foo f = { .d = 4 };
</pre>
<p>will convert 4 to a <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#float">double</a></code> to store it in the union using
the second element.  By contrast, casting 4 to type <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#union">union</a>&nbsp;foo</code>
would store it into the union as the integer <code>i</code>, since it is
an integer (see <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC84">Cast to Union</a>).
<br><br>
You can combine this technique of naming elements with ordinary C
initialization of successive elements.  Each initializer element that
does not have a designator applies to the next consecutive element of the
array or structure.  For example,</p>
<pre>int a[6] = { [1] = v1, v2, [4] = v4 };
</pre>
<p>is equivalent to</p>
<pre>int a[6] = { 0, v1, v2, 0, v4, 0 };
</pre>
<p>Labeling the elements of an array initializer is especially useful
when the indices are characters or belong to an <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#enum">enum</a></code> type.
For example:</p>
<pre>int whitespace[256]
  = { [' '] = 1, ['\t'] = 1, ['\h'] = 1,
      ['\f'] = 1, ['\n'] = 1, ['\r'] = 1 };
</pre>
<p>You can also write a series of <code>.<i>fieldname</i></code> and
<code>[<i>index</i>]</code> designators before an <code>=</code> to specify a
nested subobject to initialize; the list is taken relative to the
subobject corresponding to the closest surrounding brace pair.  For
example, with the <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#struct">struct</a>&nbsp;point</code> declaration above:</p>
<pre>struct point ptarray[10] = { [2].y = yv2, [2].x = xv2, [0].x = xv0 };
</pre>
<p>If the same field is initialized multiple times, it will have value from
the last initialization.  If any such overridden initialization has
side-effect, it is unspecified whether the side-effect happens or not.
Currently, GCC will discard them and issue a warning.</p>

<hr>
<h2><a name="SEC84"><u>Cast to a Union Type</u></a></h2>
<p>A cast to union type is similar to other casts, except that the type
specified is a union type.  You can specify the type either with
<code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#union">union</a>&nbsp;<i>tag</i></code> or with a typedef name.  A cast to union is actually
a constructor though, not a cast, and hence does not yield an lvalue like
normal casts (see <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC81">Compound Literals</a>).
<br><br>
The types that may be cast to the union type are those of the members
of the union.  Thus, given the following union and variables:</p>
<pre>union foo { int i; double d; };
int x;
double y;
</pre>
<p>both <i>x</i> and <i>y</i> can be cast to type <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#union">union</a>&nbsp;foo</code>.
<br><br>
Using the cast as the right-hand side of an assignment to a variable of
union type is equivalent to storing in a member of the union:</p>
<pre>union foo u;
/* ... */
u = (union foo) x  &lt;=&gt;  u.i = x
u = (union foo) y  &lt;=&gt;  u.d = y
</pre>
<p>You can also use the union cast as a function argument:</p>
<pre>void hack (union foo);
/* ... */
hack ((union foo) x);
</pre>

<hr>
<h2><a name="SEC83"><u>Case Ranges</u></a></h2>
<p>You can specify a range of consecutive values in a single <code>case</code> label,
like this:</p>
<pre>case <i>low</i> ... <i>high</i>:
</pre>
<p>This has the same effect as the proper number of individual <code>case</code>
labels, one for each integer value from <i>low</i> to <i>high</i>, inclusive.
<br><br>
This feature is especially useful for ranges of ASCII character codes:</p>
<pre>case 'A' ... 'Z':
</pre>
<p><b>Note:</b> Always write spaces around the <code>...</code>, for otherwise
it may be parsed wrong when you use it with integer values.  For example,
write this:</p>
<pre>case 1 ... 5:
</pre>
<p>rather than this:</p>
<pre>case 1...5:
</pre>

<hr>
<h2><a name="SEC85"><u>Specifying Attributes of Functions</u></a></h2>
<p>In GNU C, you declare certain things about functions called in your program
which help the compiler optimize function calls and check your code more
carefully.
<br><br>
The keyword <code>__attribute__</code> allows you to specify special
attributes when making a declaration.  This keyword is followed by an
attribute specification inside double parentheses.
The following attributes are currently defined for functions:</p>

<ul>
<li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC85_noreturn">noreturn</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC85_pure">pure</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC85_const">const</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC85_format">format</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC85_format_arg">format_arg</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC85_no_instrument_function">no_instrument_function</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC85_section">section</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC85_constructor">constructor, destructor</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC85_unused">unused</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC85_used">used</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC85_malloc">malloc</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC85_alias">alias</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC85_always_inline">always_inline</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC85_noinline">noinline</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC85_deprecated">deprecated</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC85_regparm">regparm, stkparm</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC85_nonnull">nonnull</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC85_nothrow">nothrow</a></b>
</li></ul>
<p>Other attributes are supported for variable declarations (see <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC91">Variable Attributes</a>)
and for types (see <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC92">Type Attributes</a>).
<br><br>
GCC4TI also defines the macros <code>CALLBACK, __ATTR_TIOS__, __ATTR_TIOS_NORETURN__, __ATTR_TIOS_CALLBACK__, __ATTR_GCC__, __ATTR_LIB_C__, __ATTR_LIB_ASM__, __ATTR_LIB_ASM_NORETURN__, __ATTR_LIB_CALLBACK_C__,</code> and <code>__ATTR_LIB_CALLBACK_ASM__</code>.
They are useful for specifying default attributes for a specific class of functions.
You only need to use them when you define a callback function.
For example, the callback function type <a href="https://debrouxl.github.io/gcc4ti/stdlib.html#compare_t">compare_t</a>
needs the attributes specified by <code>__ATTR_LIB_CALLBACK_C__</code>,
i.e. the attributes required by a callback function for a library function
written in C.  Since this is too inconvenient for the user, all three callback
attributes have been made equal, and we have defined a single <code>CALLBACK</code>
macro.
<br><br>
You may also specify attributes with <code>__</code> preceding and following
each keyword.  This allows you to use them in header files without
being concerned about a possible macro of the same name.  For example,
you may use <code>__noreturn__</code> instead of <code>noreturn</code>.
For example, as <a href="https://debrouxl.github.io/gcc4ti/alloc.html#malloc">malloc</a> is defined as a macro in the GCC4TI Library,
always use <code>__malloc__</code> instead of <code>malloc</code>.
<br><br>
See <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC85a">Attribute Syntax</a> for details of the exact syntax for using
attributes.
<br><br>
You can specify multiple attributes in a declaration by separating them
by commas within the double parentheses or by immediately following an
attribute declaration with another attribute declaration.
<br><br>
Some people object to the <code>__attribute__</code> feature, suggesting that
ISO C's <code><a href="https://debrouxl.github.io/gcc4ti/cpp.html#SEC46">#pragma</a></code> should be used instead.  At the time
<code>__attribute__</code> was designed, there were two reasons for not doing
this.</p>
<ol>
<li><p>It is impossible to generate <code>#pragma</code> commands from a macro.
</p></li>
<li><p>There is no telling what the same <code>#pragma</code> might mean in another
compiler.</p></li>
</ol>
<p>These two reasons applied to almost any application that might have been
proposed for <code>#pragma</code>.  It was basically a mistake to use
<code>#pragma</code> for <i>anything</i>.
<br><br>
The ISO C99 standard includes <code>_Pragma</code>, which now allows pragmas
to be generated from macros.  In addition, a <code>#pragma&nbsp;GCC</code>
namespace is now in use for GCC-specific pragmas.  However, it has been
found convenient to use <code>__attribute__</code> to achieve a natural
attachment of attributes to their corresponding declarations, whereas
<code>#pragma&nbsp;GCC</code> is of use for constructs that do not naturally form
part of the grammar.</p>

<h3><a name="SEC85_noreturn"><u>noreturn</u></a></h3>
<p>A few standard library functions, such as <a href="https://debrouxl.github.io/gcc4ti/stdlib.html#abort">abort</a> and <a href="https://debrouxl.github.io/gcc4ti/stdlib.html#exit">exit</a>,
cannot return.  Some programs define
their own functions that never return.  You can declare them
<code>noreturn</code> to tell the compiler this fact.  For example:</p>
<pre>void fatal () __attribute__ ((noreturn));

void
fatal (/* ... */)
{
  /* ... */ /* Print error message. */ /* ... */
  exit (1);
}
</pre>
<p>The <code>noreturn</code> keyword tells the compiler to assume that
<i>fatal</i> cannot return.  It can then optimize without regard to what
would happen if <i>fatal</i> ever did return.  This makes slightly
better code.  More importantly, it helps avoid spurious warnings of
uninitialized variables.
<br><br>
Do not assume that registers saved by the calling function are
restored before calling the <code>noreturn</code> function.
<br><br>
It does not make sense for a <code>noreturn</code> function to have a return
type other than <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#void">void</a></code>.</p>

<h3><a name="SEC85_pure"><u>pure</u></a></h3>
<p>Many functions have no effects except the return value and their
return value depends only on the parameters and/or global variables.
Such a function can be subject
to common subexpression elimination and loop optimization just as an
arithmetic operator would be.  These functions should be declared
with the attribute <code>pure</code>.  For example,</p>
<pre>int square (int) __attribute__ ((pure));
</pre>
<p>says that the hypothetical function <i>square</i> is safe to call
fewer times than the program says.
<br><br>
Some common examples of pure functions are <a href="https://debrouxl.github.io/gcc4ti/string.html#strlen">strlen</a> or <a href="https://debrouxl.github.io/gcc4ti/mem.html#memcmp">memcmp</a>.
Interesting non-pure functions are functions with infinite loops or those
depending on volatile memory or other system resource, that may change between
two consecutive calls.</p>

<p>See also: <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC85_const">const</a></p>
<h3><a name="SEC85_const"><u>const</u></a></h3>
<p>Many functions do not examine any values except their arguments, and
have no effects except the return value.  Basically this is just slightly
more strict class than the <code><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC85_pure">pure</a></code> attribute, since the function is not
allowed to read global memory.
<br><br>
Note that a function that has pointer arguments and examines the data
pointed to must <i>not</i> be declared <code>const</code>.  Likewise, a
function that calls a non-<code>const</code> function usually must not be
<code>const</code>.  It does not make sense for a <code>const</code> function to
return <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#void">void</a></code>.</p>

<p>See also: <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC85_pure">pure</a></p>
<h3><a name="SEC85_format"><u>format</u></a></h3>
<p>Syntax: <b>format (<i>archetype</i>, <i>string-index</i>, <i>first-to-check</i>)</b>
<br><br>
The <code>format</code> attribute specifies that a function takes <a href="https://debrouxl.github.io/gcc4ti/stdio.html#printf">printf</a>
style arguments which
should be type-checked against a format string.  For example, the
declaration:</p>
<pre>extern int
my_printf (void *my_object, const char *my_format, ...)
      __attribute__ ((format (printf, 2, 3)));
</pre>
<p>causes the compiler to check the arguments in calls to <i>my_printf</i>
for consistency with the <a href="https://debrouxl.github.io/gcc4ti/stdio.html#printf">printf</a> style format string argument
<i>my_format</i>.
<br><br>
The parameter <i>archetype</i> determines how the format string is
interpreted, and should be <code>printf</code>, <code>scanf</code>, <code>strftime</code>
or <code>strfmon</code> (note that only the function <a href="https://debrouxl.github.io/gcc4ti/stdio.html#printf">printf</a> is implemented in the GCC4TI Library).
(You can also use <code>__printf__</code>,
<code>__scanf__</code>, <code>__strftime__</code> or <code>__strfmon__</code>.)  The
parameter <i>string-index</i> specifies which argument is the format
string argument (starting from 1), while <i>first-to-check</i> is the
number of the first argument to check against the format string.  For
functions where the arguments are not available to be checked (such as
<a href="https://debrouxl.github.io/gcc4ti/stdio.html#vprintf">vprintf</a>), specify the third parameter as zero.  In this case the
compiler only checks the format string for consistency.  For
<code>strftime</code> formats, the third parameter is required to be zero.
<br><br>
In the example above, the format string (<i>my_format</i>) is the second
argument of the function <i>my_print</i>, and the arguments to check
start with the third argument, so the correct parameters for the format
attribute are 2 and 3.
<br><br>
The <code>format</code> attribute allows you to identify your own functions
which take format strings as arguments, so that GCC can check the
calls to these functions for errors.  The compiler always (unless
<b>'-ffreestanding'</b> is used) checks formats
for the standard library functions.
See <a href="https://debrouxl.github.io/gcc4ti/comopts.html#SEC6">Options Controlling C Dialect</a>.</p>

<h3><a name="SEC85_format_arg"><u>format_arg</u></a></h3>
<p>Syntax: <b>format_arg (<i>string-index</i>)</b>
<br><br>
The <code>format_arg</code> attribute specifies that a function takes a format
string for a <a href="https://debrouxl.github.io/gcc4ti/stdio.html#printf">printf</a> style function and modifies it (for example, to translate
it into another language), so the result can be passed to a
<a href="https://debrouxl.github.io/gcc4ti/stdio.html#printf">printf</a> style
function (with the remaining arguments to the format function the same
as they would have been for the unmodified string).  For example, the
declaration</p>
<pre>extern char *
my_dgettext (char *my_domain, const char *my_format)
      __attribute__ ((format_arg (2)));
</pre>
<p>causes the compiler to check the arguments in calls to a <a href="https://debrouxl.github.io/gcc4ti/stdio.html#printf">printf</a> type function, whose
format string argument is the result of a call to the <i>my_dgettext</i> function, for
consistency with the format string argument <i>my_format</i>.  If the
<code>format_arg</code> attribute had not been specified, all the compiler
could tell in such calls to format functions would be that the format
string argument is not constant; this would generate a warning when
<b>'-Wformat-nonliteral'</b> is used, but the calls could not be checked
without the attribute.
<br><br>
The parameter <i>string-index</i> specifies which argument is the format
string argument (starting from 1).
<br><br>
The <code>format-arg</code> attribute allows you to identify your own
functions which modify format strings, so that GCC can check the
calls to <a href="https://debrouxl.github.io/gcc4ti/stdio.html#printf">printf</a>
type functions whose operands are calls to one of your own functions.
(The compiler always treats <code>gettext</code>, <code>dgettext</code>, and
<code>dcgettext</code> in this manner except when strict ISO C support is
requested by <b>'-ansi'</b> or an appropriate <b>'-std'</b> option, or
<b>'-ffreestanding'</b> is used.  See <a href="https://debrouxl.github.io/gcc4ti/comopts.html#SEC6">Options
Controlling C Dialect</a>.)</p>

<h3><a name="SEC85_no_instrument_function"><u>no_instrument_function</u></a></h3>
<p>If <b>'-finstrument-functions'</b> is given, profiling function calls will
be generated at entry and exit of most user-compiled functions.
Functions with this attribute will not be so instrumented.</p>

<h3><a name="SEC85_section"><u>section</u></a></h3>
<p>Syntax: <b>section ("<i>section-name</i>")</b>
<br><br>
Normally, the compiler places all code and data it generates in the <code>.data</code> section.
Sometimes, however, you need additional sections, or you need certain
particular functions to appear in special sections.  The <code>section</code>
attribute specifies that a function lives in a particular section.
For example, the declaration:</p>
<pre>extern void foobar (void) __attribute__ ((section ("bar")));
</pre>
<p>puts the function <i>foobar</i> in the <code>bar</code> section.
<br><br>
The use of this attribute is limited in GCC4TI, because its linker supports
only a few types of sections.
<br><br>
The <code>section</code> attribute can also be used for <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC91_section">variables</a>.</p>

<h3><a name="SEC85_constructor"><u>constructor, destructor</u></a></h3>
<p>The <code>constructor</code> attribute causes the function to be called
automatically before execution enters _main.  Similarly, the
<code>destructor</code> attribute causes the function to be called
automatically after _main has completed or <a href="https://debrouxl.github.io/gcc4ti/stdlib.html#exit">exit</a> has
been called.  Functions with these attributes are useful for
initializing data that will be used implicitly during the execution of
the program.</p>

<h3><a name="SEC85_unused"><u>unused</u></a></h3>
<p>This attribute, attached to a function, means that the function is meant
to be possibly unused.  GCC will not produce a warning for this
function.
<br><br>
The <code>unused</code> attribute can also be used for <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC91_unused">variables</a> and
<a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC92_unused">types</a>.</p>

<h3><a name="SEC85_used"><u>used</u></a></h3>
<p>This attribute, attached to a function, means that code must be emitted
for the function even if it appears that the function is not referenced.
This is useful, for example, when the function is referenced only in
inline assembly.</p>

<h3><a name="SEC85_malloc"><u>malloc</u></a></h3>
<p>The <code>malloc</code> attribute is used to tell the compiler that a function
may be treated as if it were the <a href="https://debrouxl.github.io/gcc4ti/alloc.html#malloc">malloc</a> function.  The compiler assumes
that calls to <a href="https://debrouxl.github.io/gcc4ti/alloc.html#malloc">malloc</a> result in a pointers that cannot alias anything.
This will often improve optimization.</p>

<h3><a name="SEC85_alias"><u>alias</u></a></h3>
<p>Syntax: <b>alias ("<i>target</i>")</b>
<br><br>
The <code>alias</code> attribute causes the declaration to be emitted as an
alias for another symbol, which must be specified.  For instance,</p>
<pre>void __f () { /* Do something. */; }
void f () __attribute__ ((weak, alias ("__f")));
</pre>
<p>declares <i>f</i> to be a weak alias for <i>__f</i>.
<br><br>
Not all target machines support this attribute.
We haven't tested yet whether it is supported for the Motorola 68000.</p>

<h3><a name="SEC85_always_inline"><u>always_inline</u></a></h3>
<p>Generally, functions are not inlined unless optimization is specified.
For functions declared inline, this attribute inlines the function even
if no optimization level was specified.</p>

<h3><a name="SEC85_noinline"><u>noinline</u></a></h3>
<p>This function attribute prevents a function from being considered for
inlining.</p>

<h3><a name="SEC85_deprecated"><u>deprecated</u></a></h3>
<p>The <code>deprecated</code> attribute results in a warning if the function
is used anywhere in the source file.  This is useful when identifying
functions that are expected to be removed in a future version of a
program.  The warning also includes the location of the declaration
of the deprecated function, to enable users to easily find further
information about why the function is deprecated, or what they should
do instead.  Note that the warnings only occurs for uses:</p>
<pre>int old_fn () __attribute__ ((deprecated));
int old_fn ();
int (*fn_ptr)() = old_fn;
</pre>
<p>results in a warning on line 3 but not line 2.
<br><br>
The <code>deprecated</code> attribute can also be used for <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC91_deprecated">variables</a> and
<a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC92_deprecated">types</a>.</p>

<h3><a name="SEC85_regparm"><u>regparm, stkparm</u></a></h3>
<p>Syntax: <b>regparm [(<i>regcount</i>)]</b> / <b>stkparm</b>
<br><br>
The <code>regparm</code> attribute causes the function to use <i>regcount</i>
data registers and <i>regcount</i> address registers for parameters.
<code>stkparm</code> means the exact opposite, i.e. all parameters are passed
on the stack.  The <b>'-mregparm'</b> switch specifies which one is the default,
and the default for <i>regcount</i>.</p>

<p>See also: <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC99a">Specifying Registers for Function Parameters</a></p>
<h3><a name="SEC85_nonnull"><u>nonnull</u></a></h3>
<p>Syntax: <b>nonnull [(<i>param1</i>[, <i>param2</i>[, ...]])]</b>
<br><br>
The <code>nonnull</code> attribute specifies that some function parameters should
be non-null pointers.  For instance, the declaration:</p>
<pre>extern void *
my_memcpy (void *dest, const void *src, size_t len)
	__attribute__((nonnull (1, 2)));
</pre>
<p>causes the compiler to check that, in calls to <code>my_memcpy</code>,
arguments <i>dest</i> and <i>src</i> are non-null.  If the compiler
determines that a null pointer is passed in an argument slot marked
as non-null, and the <b>'-Wnonnull'</b> option is enabled, a warning
is issued.  The compiler may also choose to make optimizations based
on the knowledge that certain function arguments will not be null.
<br><br>
If no argument index list is given to the <code>nonnull</code> attribute,
all pointer arguments are marked as non-null.  To illustrate, the
following declaration is equivalent to the previous example:</p>
<pre>extern void *
my_memcpy (void *dest, const void *src, size_t len)
	__attribute__((nonnull));
</pre>

<h3><a name="SEC85_nothrow"><u>nothrow</u></a></h3>
<p>The <code>nothrow</code> attribute is used to inform the compiler that a
function cannot throw an exception.
This is probably useless in GCC4TI, as it implements its own error-handling
mechanism.</p>

<hr>
<h2><a name="SEC91"><u>Specifying Attributes of Variables</u></a></h2>
<p>The keyword <code>__attribute__</code> allows you to specify special
attributes of variables or structure fields.  This keyword is followed
by an attribute specification inside double parentheses.
The following attributes are currently defined for variables:</p>

<ul>
<li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC91_aligned">aligned</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC91_mode">mode</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC91_nocommon">nocommon</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC91_packed">packed</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC91_section">section</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC91_transparent_union">transparent_union</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC91_cleanup">cleanup</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC91_unused">unused</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC91_deprecated">deprecated</a></b>
</li></ul>
<p>Other attributes are
available for functions (see <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC85">Function Attributes</a>) and for types
(see <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC92">Type Attributes</a>).
<br><br>
You may also specify attributes with <code>__</code> preceding and following
each keyword.  This allows you to use them in header files without
being concerned about a possible macro of the same name.  For example,
you may use <code>__aligned__</code> instead of <code>aligned</code>.
<br><br>
See <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC85a">Attribute Syntax</a> for details of the exact syntax for using
attributes.
<br><br>
To specify multiple attributes, separate them by commas within the
double parentheses: for example, <code>__attribute__&nbsp;((aligned&nbsp;(16),
packed))</code>.</p>

<h3><a name="SEC91_aligned"><u>aligned</u></a></h3>
<p>Syntax: <b>aligned [(<i>alignment</i>)]</b>
<br><br>
This attribute specifies a minimum alignment for the variable or
structure field, measured in bytes.  For example, the declaration:</p>
<pre>int x __attribute__ ((aligned (4))) = 0;
</pre>
<p>causes the compiler to allocate the global variable <code>x</code> on a
4-byte boundary.
<br><br>
You can also specify the alignment of structure fields.  For example, to
create a 4-byte aligned <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#int">int</a></code> pair, you could write:</p>
<pre>struct foo { int x[2] __attribute__ ((aligned (4))); };
</pre>
<p>As in the preceding examples, you can explicitly specify the alignment
(in bytes) that you wish the compiler to use for a given variable or
structure field.  Alternatively, you can leave out the alignment factor
and just ask the compiler to align a variable or field to the maximum
useful alignment for the target machine you are compiling for.  For
example, you could write:</p>
<pre>short array[3] __attribute__ ((aligned));
</pre>
<p>Whenever you leave out the alignment factor in an <code>aligned</code> attribute
specification, the compiler automatically sets the alignment for the declared
variable or field to the largest alignment which is ever used for any data
type on the target machine you are compiling for (useless in GCC4TI, since everything
is already aligned well enough with the default 2-byte alignment).
<br><br>
The <code>aligned</code> attribute can only increase the alignment; but you
can decrease it by specifying <code><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC91_packed">packed</a></code> as well.</p>

<h3><a name="SEC91_mode"><u>mode</u></a></h3>
<p>Syntax: <b>mode (<i>mode</i>)</b>
<br><br>
This attribute specifies the data type for the declaration - whichever
type corresponds to the mode <i>mode</i>.  This in effect lets you
request an integer or floating point type according to its width.
<br><br>
You may also specify a mode of <code>byte</code> or <code>__byte__</code> to
indicate the mode corresponding to a one-byte integer, <code>word</code> or
<code>__word__</code> for the mode of a one-word integer, and <code>pointer</code>
or <code>__pointer__</code> for the mode used to represent pointers.</p>

<h3><a name="SEC91_nocommon"><u>nocommon</u></a></h3>
<p>This attribute requests GCC not to place a variable
"common" but instead to allocate space for it directly.  If you
specify the <b>'-fno-common'</b> flag, GCC will do this for all
variables.
<br><br>
Specifying the <code>nocommon</code> attribute for a variable provides an
initialization of zeros.  A variable may only be initialized in one
source file.</p>

<h3><a name="SEC91_packed"><u>packed</u></a></h3>
<p>The <code>packed</code> attribute specifies that a variable or structure field
should have the smallest possible alignment - one byte for a variable,
and one bit for a field, unless you specify a larger value with the
<code>aligned</code> attribute.
<br><br>
Here is a structure in which the field <code>x</code> is packed, so that it
immediately follows <code>a</code>:</p>
<pre>struct foo
{
  char a;
  int x[2] __attribute__ ((packed));
};
</pre>

<h3><a name="SEC91_section"><u>section</u></a></h3>
<p>Syntax: <b>section ("<i>section-name</i>")</b>
<br><br>
Normally, the compiler places the objects it generates in sections like
<code>.data</code> and <code>.bss</code>.  Sometimes, however, you need additional sections,
or you need certain particular variables to appear in special sections,
for example to map to special hardware.  The <code>section</code>
attribute specifies that a variable (or function) lives in a particular
section.  The use of this attribute is limited in GCC4TI, because its linker supports
only a few types of sections, but this may be improved in the future.
For example, this small hypothetical program uses several specific section names:</p>
<pre>struct duart a __attribute__ ((section ("DUART_A"))) = { 0 };
struct duart b __attribute__ ((section ("DUART_B"))) = { 0 };
char stack[10000] __attribute__ ((section ("STACK"))) = { 0 };
int init_data __attribute__ ((section ("INITDATA"))) = 0;

main()
{
  /* Initialize stack pointer */
  init_sp (stack + sizeof (stack));

  /* Initialize initialized data */
  memcpy (&amp;init_data, &amp;data, &amp;edata - &amp;data);

  /* Turn on the serial ports */
  init_duart (&amp;a);
  init_duart (&amp;b);
}
</pre>
<p>Use the <code>section</code> attribute with an <i>initialized</i> definition
of a <i>global</i> variable, as shown in the example.  GCC issues
a warning and otherwise ignores the <code>section</code> attribute in
uninitialized variable declarations.
<br><br>
You may only use the <code>section</code> attribute with a fully initialized
global definition because of the way linkers work.  The linker requires
each object be defined once, with the exception that uninitialized
variables tentatively go in the <code>.bss</code> section
and can be multiply "defined".  You can force a variable to be
initialized with the <b>'-fno-common'</b> flag or the <code><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC91_nocommon">nocommon</a></code>
attribute.
<br><br>
The <code>section</code> attribute can also be used for <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC85_section">functions</a>.</p>

<h3><a name="SEC91_transparent_union"><u>transparent_union</u></a></h3>
<p>This attribute, attached to a function parameter which is a union, means
that the corresponding argument may have the type of any union member,
but the argument is passed as if its type were that of the first union
member.  For more details, see the
<code><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC92_transparent_union">transparent_union</a></code>
type attribute.  You can also use
this attribute on a <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#typedef">typedef</a></code> for a union data type; then it
applies to all function parameters with that type.</p>

<h3><a name="SEC91_cleanup"><u>cleanup</u></a></h3>
<p>The <code>cleanup</code> attribute runs a function when the variable goes
out of scope.  This attribute can only be applied to auto function
scope variables; it may not be applied to parameters or variables
with static storage duration.  The function must take one parameter,
a pointer to a type compatible with the variable.  The return value
of the function (if any) is ignored.
<br><br>
If <b>'-fexceptions'</b> is enabled, then <i>cleanup_function</i>
will be run during the stack unwinding that happens during the
processing of the exception.  Note that the <code>cleanup</code> attribute
does not allow the exception to be caught, only to perform an action.
Note that GCC4TI defines its own error handling mechanism, so this attribute
will not work if used in this way.
It is undefined what happens if <i>cleanup_function</i> does not
return normally.</p>

<h3><a name="SEC91_unused"><u>unused</u></a></h3>
<p>This attribute, attached to a variable, means that the variable is meant
to be possibly unused.  GCC will not produce a warning for this
variable.
<br><br>
The <code>unused</code> attribute can also be used for <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC85_unused">functions</a> and
<a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC92_unused">types</a>.</p>

<h3><a name="SEC91_deprecated"><u>deprecated</u></a></h3>
<p>The <code>deprecated</code> attribute results in a warning if the variable
is used anywhere in the source file.  This is useful when identifying
variables that are expected to be removed in a future version of a
program.  The warning also includes the location of the declaration
of the deprecated variable, to enable users to easily find further
information about why the variable is deprecated, or what they should
do instead.  Note that the warnings only occurs for uses:</p>
<pre>extern int old_var __attribute__ ((deprecated));
extern int old_var;
int new_fn () { return old_var; }
</pre>
<p>results in a warning on line 3 but not line 2.
<br><br>
The <code>deprecated</code> attribute can also be used for <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC85_deprecated">functions</a> and
<a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC92_deprecated">types</a>.</p>

<hr>
<h2><a name="SEC92"><u>Specifying Attributes of Types</u></a></h2>
<p>The keyword <code>__attribute__</code> allows you to specify special
attributes of <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#struct">struct</a></code> and <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#union">union</a></code> types when you define such
types.  This keyword is followed by an attribute specification inside
double parentheses.
The following attributes are currently defined for types:</p>

<ul>
<li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC92_aligned">aligned</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC92_packed">packed</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC92_transparent_union">transparent_union</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC92_may_alias">may_alias</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC92_unused">unused</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC92_deprecated">deprecated</a></b>
</li></ul>
<p>Other attributes are defined for
functions (see <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC85">Function Attributes</a>) and for variables
(see <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC91">Variable Attributes</a>).
<br><br>
You may also specify any one of these attributes with <code>__</code>
preceding and following its keyword.  This allows you to use these
attributes in header files without being concerned about a possible
macro of the same name.  For example, you may use <code>__aligned__</code>
instead of <code>aligned</code>.
<br><br>
You may specify the <code>aligned</code> and <code>transparent_union</code>
attributes either in a <code>typedef</code> declaration or just past the
closing curly brace of a complete enum, struct or union type
<i>definition</i> and the <code>packed</code> attribute only past the closing
brace of a definition.
<br><br>
You may also specify attributes between the enum, struct or union
tag and the name of the type rather than after the closing brace.
<br><br>
See <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC85a">Attribute Syntax</a> for details of the exact syntax for using
attributes.
<br><br>
To specify multiple attributes, separate them by commas within the
double parentheses: for example, <code>__attribute__&nbsp;((aligned&nbsp;(16),
packed))</code>.</p>

<h3><a name="SEC92_aligned"><u>aligned</u></a></h3>
<p>Syntax: <b>aligned [(<i>alignment</i>)]</b>
<br><br>
This attribute specifies a minimum alignment (in bytes) for variables
of the specified type.  For example, the declarations:</p>
<pre>struct S { short f[3]; } __attribute__ ((aligned (8)));
typedef int more_aligned_int __attribute__ ((aligned (8)));
</pre>
<p>force the compiler to insure (as far as it can) that each variable whose
type is <code>struct&nbsp;S</code> or <code>more_aligned_int</code> will be allocated and
aligned <i>at least</i> on a 8-byte boundary.
<br><br>
Note that the alignment of any given <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#struct">struct</a></code> or <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#union">union</a></code> type
is required by the ISO C standard to be at least a perfect multiple of
the lowest common multiple of the alignments of all of the members of
the <code>struct</code> or <code>union</code> in question.  This means that you <i>can</i>
effectively adjust the alignment of a <code>struct</code> or <code>union</code>
type by attaching an <code>aligned</code> attribute to any one of the members
of such a type, but the notation illustrated in the example above is a
more obvious, intuitive, and readable way to request the compiler to
adjust the alignment of an entire <code>struct</code> or <code>union</code> type.
<br><br>
As in the preceding example, you can explicitly specify the alignment
(in bytes) that you wish the compiler to use for a given <code>struct</code>
or <code>union</code> type.  Alternatively, you can leave out the alignment factor
and just ask the compiler to align a type to the maximum
useful alignment for the target machine you are compiling for.  For
example, you could write:</p>
<pre>struct S { short f[3]; } __attribute__ ((aligned));
</pre>
<p>Whenever you leave out the alignment factor in an <code>aligned</code>
attribute specification, the compiler automatically sets the alignment
for the type to the largest alignment which is ever used for any data
type on the target machine you are compiling for (useless in GCC4TI, since everything
is already aligned well enough with the default 2-byte alignment).
<br><br>
The <code>aligned</code> attribute can only increase the alignment; but you
can decrease it by specifying <code><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC91_packed">packed</a></code> as well.</p>

<h3><a name="SEC92_packed"><u>packed</u></a></h3>
<p>This attribute, attached to an <code>enum</code>, <code>struct</code>, or
<code>union</code> type definition, specified that the minimum required memory
be used to represent the type.
<br><br>
Specifying this attribute for <code>struct</code> and <code>union</code> types is
equivalent to specifying the <code>packed</code> attribute on each of the
structure or union members.  Specifying the <b>'-fshort-enums'</b>
flag on the line is equivalent to specifying the <code>packed</code>
attribute on all <code>enum</code> definitions.
<br><br>
You may only specify this attribute after a closing curly brace on an
<code>enum</code> definition, not in a <code>typedef</code> declaration, unless that
declaration also contains the definition of the <code>enum</code>.</p>

<h3><a name="SEC92_transparent_union"><u>transparent_union</u></a></h3>
<p>This attribute, attached to a <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#union">union</a></code> type definition, indicates
that any function parameter having that union type causes calls to that
function to be treated in a special way.
<br><br>
First, the argument corresponding to a transparent union type can be of
any type in the union; no cast is required.  Also, if the union contains
a pointer type, the corresponding argument can be a null pointer
constant or a void pointer expression; and if the union contains a void
pointer type, the corresponding argument can be any pointer expression.
If the union member type is a pointer, qualifiers like <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#const">const</a></code> on
the referenced type must be respected, just as with normal pointer
conversions.
<br><br>
Second, the argument is passed to the function using the calling
conventions of first member of the transparent union, not the calling
conventions of the union itself.  All members of the union must have the
same machine representation; this is necessary for this argument passing
to work properly.
<br><br>
Transparent unions are designed for library functions that have multiple
interfaces for compatibility reasons, but they may be used for various
different purposes.</p>

<h3><a name="SEC92_may_alias"><u>may_alias</u></a></h3>
<p>Accesses to objects with types with this attribute are not subjected to
type-based alias analysis, but are instead assumed to be able to alias
any other type of objects, just like the <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#int">char</a></code> type.  See
<b>'-fstrict-aliasing'</b> for more information on aliasing issues.
<br><br>
Example of use:</p>
<pre>typedef short __attribute__((__may_alias__)) short_a;

void _main (void)
{
  long a = 0x12345678;
  short_a *b = (short_a *) &amp;a;

  b[1] = 0;

  if (a == 0x12345678)
    abort();

  /* ... */
}
</pre>
<p>If you replaced <code>short_a</code> with <code>short</code> in the variable
declaration, the above program would abort when compiled with
<b>'-fstrict-aliasing'</b>, which is on by default at <b>'-O2'</b> or
above in recent GCC versions.</p>

<h3><a name="SEC92_unused"><u>unused</u></a></h3>
<p>When attached to a type (including a <code>union</code> or a <code>struct</code>),
this attribute means that variables of that type are meant to appear
possibly unused.  GCC will not produce a warning for any variables of
that type, even if the variable appears to do nothing.
<br><br>
The <code>unused</code> attribute can also be used for <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC85_unused">functions</a> and
<a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC91_unused">variables</a>.</p>

<h3><a name="SEC92_deprecated"><u>deprecated</u></a></h3>
<p>The <code>deprecated</code> attribute results in a warning if the type
is used anywhere in the source file.  This is useful when identifying
types that are expected to be removed in a future version of a program.
If possible, the warning also includes the location of the declaration
of the deprecated type, to enable users to easily find further
information about why the type is deprecated, or what they should do
instead.  Note that the warnings only occur for uses and then only
if the type is being applied to an identifier that itself is not being
declared as deprecated.</p>
<pre>typedef int T1 __attribute__ ((deprecated));
T1 x;
typedef T1 T2;
T2 y;
typedef T1 T3 __attribute__ ((deprecated));
T3 z __attribute__ ((deprecated));
</pre>
<p>results in a warning on line 2 and 3 but not lines 4, 5, or 6.  No
warning is issued for line 4 because T2 is not explicitly
deprecated.  Line 5 has no warning because T3 is explicitly
deprecated.  Similarly for line 6.
<br><br>
The <code>deprecated</code> attribute can also be used for <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC85_deprecated">functions</a> and
<a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC91_deprecated">variables</a>.</p>

<hr>
<h2><a name="SEC85a"><u>Attribute Syntax</u></a></h2>
<p>This section describes the syntax with which <code>__attribute__</code> may be
used, and the constructs to which attribute specifiers bind, for the C
language.  Because of
infelicities in the grammar for attributes, some forms described here
may not be successfully parsed in all cases.
<br><br>
See <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC85">Function Attributes</a> for details of the semantics of attributes
applying to functions.  See <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC91">Variable Attributes</a> for details of the
semantics of attributes applying to variables.  See <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC92">Type Attributes</a>
for details of the semantics of attributes applying to structure, union
and enumerated types.
<br><br>
An <u>attribute specifier</u> is of the form
<code>__attribute__&nbsp;((<i>attribute-list</i>))</code>.  An <u>attribute list</u>
is a possibly empty comma-separated sequence of <u>attributes</u>, where
each attribute is one of the following:</p>
<ul>
<li><p>Empty.  Empty attributes are ignored.
</p></li>
<li><p>A word (which may be an identifier such as <code>unused</code>, or a reserved
word such as <code>const</code>).
</p></li>
<li><p>A word, followed by, in parentheses, parameters for the attribute.
These parameters take one of the following forms:</p>
<ul>
<li><p>An identifier.  For example, <code>mode</code> attributes use this form.
</p></li>
<li><p>An identifier followed by a comma and a non-empty comma-separated list
of expressions.  For example, <code>format</code> attributes use this form.
</p></li>
<li><p>A possibly empty comma-separated list of expressions.  For example,
<code>format_arg</code> attributes use this form with the list being a single
integer constant expression, and <code>alias</code> attributes use this form
with the list being a single string constant.</p></li>
</ul>

</li>
</ul>
<p>An <u>attribute specifier list</u> is a sequence of one or more attribute
specifiers, not separated by any other tokens.
<br><br>
An attribute specifier list may appear after the colon following a
label, other than a <code>case</code> or <code>default</code> label.  The only
attribute it makes sense to use after a label is <code>unused</code>.  This
feature is intended for code generated by programs which contains labels
that may be unused but which is compiled with <b>'-Wall'</b>.  It would
not normally be appropriate to use in it human-written code, though it
could be useful in cases where the code that jumps to the label is
contained within an <code>#ifdef</code> conditional.
<br><br>
An attribute specifier list may appear as part of a <code>struct</code>,
<code>union</code> or <code>enum</code> specifier.  It may go either immediately
after the <code>struct</code>, <code>union</code> or <code>enum</code> keyword, or after
the closing brace.  It is ignored if the content of the structure, union
or enumerated type is not defined in the specifier in which the
attribute specifier list is used - that is, in usages such as
<code>struct&nbsp;__attribute__((foo))&nbsp;bar</code> with no following opening brace.
Where attribute specifiers follow the closing brace, they are considered
to relate to the structure, union or enumerated type defined, not to any
enclosing declaration the type specifier appears in, and the type
defined is not complete until after the attribute specifiers.
<br><br>
Otherwise, an attribute specifier appears as part of a declaration,
counting declarations of unnamed parameters and type names, and relates
to that declaration (which may be nested in another declaration, for
example in the case of a parameter declaration), or to a particular declarator
within a declaration.  Where an
attribute specifier is applied to a parameter declared as a function or
an array, it should apply to the function or array rather than the
pointer to which the parameter is implicitly converted, but this is not
yet correctly implemented.
<br><br>
Any list of specifiers and qualifiers at the start of a declaration may
contain attribute specifiers, whether or not such a list may in that
context contain storage class specifiers.  (Some attributes, however,
are essentially in the nature of storage class specifiers, and only make
sense where storage class specifiers may be used; for example,
<code>section</code>.)  There is one necessary limitation to this syntax: the
first old-style parameter declaration in a function definition cannot
begin with an attribute specifier, because such an attribute applies to
the function instead by syntax described below (which, however, is not
yet implemented in this case).  In some other cases, attribute
specifiers are permitted by this grammar but not yet supported by the
compiler.  All attribute specifiers in this place relate to the
declaration as a whole.  In the obsolescent usage where a type of
<code>int</code> is implied by the absence of type specifiers, such a list of
specifiers and qualifiers may be an attribute specifier list with no
other specifiers or qualifiers.
<br><br>
An attribute specifier list may appear immediately before a declarator
(other than the first) in a comma-separated list of declarators in a
declaration of more than one identifier using a single list of
specifiers and qualifiers.  Such attribute specifiers apply
only to the identifier before whose declarator they appear.  For
example, in</p>
<pre>__attribute__((noreturn)) void d0 (void),
    __attribute__((format(printf, 1, 2))) d1 (const char *, ...),
     d2 (void)
</pre>
<p>the <code>noreturn</code> attribute applies to all the functions
declared; the <code>format</code> attribute only applies to <code>d1</code>.
<br><br>
An attribute specifier list may appear immediately before the comma,
<code>=</code> or semicolon terminating the declaration of an identifier other
than a function definition.  At present, such attribute specifiers apply
to the declared object or function, but in future they may attach to the
outermost adjacent declarator.  In simple cases there is no difference,
but, for example, in</p>
<pre>void (****f)(void) __attribute__((noreturn));
</pre>
<p>at present the <code>noreturn</code> attribute applies to <code>f</code>, which
causes a warning since <code>f</code> is not a function, but in future it may
apply to the function <code>****f</code>.  The precise semantics of what
attributes in such cases will apply to are not yet specified.  Where an
assembler name for an object or function is specified (see <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC96">Asm
Labels</a>), at present the attribute must follow the <code>asm</code>
specification; in future, attributes before the <code>asm</code> specification
may apply to the adjacent declarator, and those after it to the declared
object or function.
<br><br>
An attribute specifier list may, in future, be permitted to appear after
the declarator in a function definition (before any old-style parameter
declarations or the function body).
<br><br>
Attribute specifiers may be mixed with type qualifiers appearing inside
the <code>[]</code> of a parameter array declarator, in the C99 construct by
which such qualifiers are applied to the pointer to which the array is
implicitly converted.  Such attribute specifiers apply to the pointer,
not to the array, but at present this is not implemented and they are
ignored.
<br><br>
An attribute specifier list may appear at the start of a nested
declarator.  At present, there are some limitations in this usage: the
attributes correctly apply to the declarator, but for most individual
attributes the semantics this implies are not implemented.
When attribute specifiers follow the <code>*</code> of a pointer
declarator, they may be mixed with any type qualifiers present.
The following describes the formal semantics of this syntax.  It will make the
most sense if you are familiar with the formal specification of
declarators in the ISO C standard.
<br><br>
Consider (as in C99 subclause 6.7.5 paragraph 4) a declaration <code>T
D1</code>, where <code>T</code> contains declaration specifiers that specify a type
<i>Type</i> (such as <code>int</code>) and <code>D1</code> is a declarator that
contains an identifier <i>ident</i>.  The type specified for <i>ident</i>
for derived declarators whose type does not include an attribute
specifier is as in the ISO C standard.
<br><br>
If <code>D1</code> has the form <code>(&nbsp;<i>attribute-specifier-list</i>&nbsp;D&nbsp;)</code>,
and the declaration <code>T&nbsp;D</code> specifies the type
"<i>derived-declarator-type-list</i> <i>Type</i>" for <i>ident</i>, then
<code>T&nbsp;D1</code> specifies the type "<i>derived-declarator-type-list</i>
<i>attribute-specifier-list</i> <i>Type</i>" for <i>ident</i>.
<br><br>
If <code>D1</code> has the form <code>*
<i>type-qualifier-and-attribute-specifier-list</i>&nbsp;D</code>, and the
declaration <code>T&nbsp;D</code> specifies the type
"<i>derived-declarator-type-list</i> <i>Type</i>" for <i>ident</i>, then
<code>T&nbsp;D1</code> specifies the type "<i>derived-declarator-type-list</i>
<i>type-qualifier-and-attribute-specifier-list</i> <i>Type</i>" for
<i>ident</i>.
<br><br>
For example,</p>
<pre>void (__attribute__((noreturn)) ****f) (void);
</pre>
<p>specifies the type "pointer to pointer to pointer to pointer to
non-returning function returning <code>void</code>".  As another example,</p>
<pre>char *__attribute__((aligned(8))) *f;
</pre>
<p>specifies the type "pointer to 8-byte-aligned pointer to <code>char</code>".
Note again that this does not work with most attributes; for example,
the usage of <code>aligned</code> and <code>noreturn</code> attributes given above
is not yet supported.
<br><br>
For compatibility with existing code written for compiler versions that
did not implement attributes on nested declarators, some laxity is
allowed in the placing of attributes.  If an attribute that only applies
to types is applied to a declaration, it will be treated as applying to
the type of that declaration.  If an attribute that only applies to
declarations is applied to the type of a declaration, it will be treated
as applying to that declaration; and, for compatibility with code
placing the attributes immediately before the identifier declared, such
an attribute applied to a function return type will be treated as
applying to the function type, and such an attribute applied to an array
element type will be treated as applying to the array type.  If an
attribute that only applies to function types is applied to a
pointer-to-function type, it will be treated as applying to the pointer
target type; if such an attribute is applied to a function return type
that is not a pointer-to-function type, it will be treated as applying
to the function type.</p>

<hr>
<h2><a name="SEC86"><u>Prototypes and Old-Style Function Definitions</u></a></h2>
<p>GNU C extends ISO C to allow a function prototype to override a later
old-style non-prototype definition.  Consider the following example:</p>
<pre>/* Use prototypes unless the compiler is old-fashioned.  */
#ifdef __STDC__
#define P(x) x
#else
#define P(x) ()
#endif

/* Prototype function declaration.  */
int isroot P((uid_t));

/* Old-style function definition.  */
int
isroot (x)   /* ??? lossage here ??? */
     uid_t x;
{
  return x == 0;
}
</pre>
<p>Suppose the type <code>uid_t</code> happens to be <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#int">char</a></code>.  ISO C does
not allow this example, because subword arguments in old-style
non-prototype definitions are promoted.  Therefore in this example the
function definition's argument is really an <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#int">int</a></code>, which does not
match the prototype argument type of <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#int">char</a></code>.
<br><br>
This restriction of ISO C makes it hard to write code that is portable
to traditional C compilers, because the programmer does not know
whether the <code>uid_t</code> type is <code>short</code>, <code>int</code>, or
<code>long</code>.  Therefore, in cases like these GNU C allows a prototype
to override a later old-style definition.  More precisely, in GNU C, a
function prototype argument type overrides the argument type specified
by a later old-style definition if the former type is the same as the
latter type before promotion.  Thus in GNU C the above example is
equivalent to the following:</p>
<pre>int isroot (uid_t);

int
isroot (uid_t x)
{
  return x == 0;
}
</pre>

<hr>
<h2><a name="SEC87"><u>C++ Style Comments</u></a></h2>
<p>In GNU C, you may use C++ style comments, which start with <code>//</code> and
continue until the end of the line.  Many other C implementations allow
such comments, and they are included in the 1999 C standard.  However,
C++ style comments are not recognized if you specify an <b>'-std'</b>
option specifying a version of ISO C before C99, or <b>'-ansi'</b>
(equivalent to <b>'-std=c89'</b>).</p>

<hr>
<h2><a name="SEC88"><u>Dollar Signs in Identifier Names</u></a></h2>
<p>In GNU C, you may normally use dollar signs in identifier names.
This is because many traditional C implementations allow such identifiers.</p>

<hr>
<h2><a name="SEC89"><u>Escape Character in Constants</u></a></h2>
<p>You can use the sequence <code>\e</code> in a string or character constant to
stand for the ASCII character ESC (<code>\x1B</code>).</p>

<hr>
<h2><a name="SEC90"><u>Inquiring on Alignment of Types or Variables</u></a></h2>
<p>The keyword <code>__alignof__</code> allows you to inquire about how an object
is aligned, or the minimum alignment usually required by a type.  Its
syntax is just like <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#sizeof">sizeof</a></code>.
<br><br>
In GCC4TI, <code>__alignof__&nbsp;(<i>anything</i>)</code> is always 2, except for
<code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#int">char</a></code> variables.
<br><br>
If the operand of <code>__alignof__</code> is an lvalue rather than a type,
its value is the required alignment for its type, taking into account
any minimum alignment specified with GCC's <code><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC91_aligned">aligned</a></code> attribute.  For example, after this
declaration:</p>
<pre>struct foo { int x; char y; } foo1;
</pre>
<p>the value of <code>__alignof__&nbsp;(foo1.y)</code> is 1, even though its actual
alignment is 2, the same as <code>__alignof__&nbsp;(int)</code>.
<br><br>
It is an error to ask for the alignment of an incomplete type.</p>

<hr>
<h2><a name="SEC93"><u>Inline Functions</u></a></h2>
<p>By declaring a function <code>inline</code>, you can direct GCC to
integrate that function's code into the code for its callers.  This
makes execution faster by eliminating the function-call overhead; in
addition, if any of the actual argument values are constant, their known
values may permit simplifications at compile time so that not all of the
inline function's code needs to be included.  The effect on code size is
less predictable; object code may be larger or smaller with function
inlining, depending on the particular case.  Inlining of functions is an
optimization and it really "works" only in optimizing compilation.  If
you don't use <b>'-O'</b>, no function is really inline.
<br><br>
Inline functions are included in the ISO C99 standard, but there are
currently substantial differences between what GCC implements and what
the ISO C99 standard requires.
<br><br>
To declare a function inline, use the <code>inline</code> keyword in its
declaration, like this:</p>
<pre>inline int
inc (int *a)
{
  (*a)++;
}
</pre>
<p>(If you are writing a header file to be included in ISO C programs, write
<code>__inline__</code> instead of <code>inline</code>.  See <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC100">Alternate Keywords</a>.)
You can also make all "simple enough" functions inline with the option
<b>'-finline-functions'</b>.
<br><br>
Note that certain usages in a function definition can make it unsuitable
for inline substitution.  Among these usages are: use of a variable number of arguments, use of
<a href="https://debrouxl.github.io/gcc4ti/alloc.html#alloca">alloca</a>, use of variable sized data types (see <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC76">Variable Length Arrays</a>),
use of computed goto (see <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC65">Labels as Values</a>), use of nonlocal goto,
and nested functions (see <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC66">Nested Functions</a>).  Using <b>'-Winline'</b>
will warn when a function marked <code>inline</code> could not be substituted,
and will give the reason for the failure.
<br><br>
Note that in C (unlike C++), the <code>inline</code> keyword
does not affect the linkage of the function.
<br><br>
When a function is both inline and <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#static">static</a></code>, if all calls to the
function are integrated into the caller, and the function's address is
never used, then the function's own assembler code is never referenced.
In this case, GCC does not actually output assembler code for the
function, unless you specify the option <b>'-fkeep-inline-functions'</b>.
Some calls cannot be integrated for various reasons (in particular,
calls that precede the function's definition cannot be integrated, and
neither can recursive calls within the definition).  If there is a
nonintegrated call, then the function is compiled to assembler code as
usual.  The function must also be compiled as usual if the program
refers to its address, because that can't be inlined.
<br><br>
When an inline function is not <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#static">static</a></code>, then the compiler must assume
that there may be calls from other source files; since a global symbol can
be defined only once in any program, the function must not be defined in
the other source files, so the calls therein cannot be integrated.
Therefore, a non-<code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#static">static</a></code> inline function is always compiled on its
own in the usual fashion.
<br><br>
If you specify both <code>inline</code> and <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#extern">extern</a></code> in the function
definition, then the definition is used only for inlining.  In no case
is the function compiled on its own, not even if you refer to its
address explicitly.  Such an address becomes an external reference, as
if you had only declared the function, and had not defined it.
<br><br>
This combination of <code>inline</code> and <code>extern</code> has almost the
effect of a macro.  The way to use it is to put a function definition in
a header file with these keywords, and put another copy of the
definition (lacking <code>inline</code> and <code>extern</code>) in a library file.
The definition in the header file will cause most calls to the function
to be inlined.  If any uses of the function remain, they will refer to
the single copy in the library.
<br><br>
For future compatibility with when GCC implements ISO C99 semantics for
inline functions, it is best to use <code>static&nbsp;inline</code> only.  (The
existing semantics will remain available when <b>'-std=gnu89'</b> is
specified, but eventually the default will be <b>'-std=gnu99'</b> and
that will implement the C99 semantics, though it does not do so yet.)
<br><br>
GCC does not inline any functions when not optimizing unless you specify
the <code><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC85_always_inline">always_inline</a></code> attribute for the function, like this:</p>
<pre>/* Prototype.  */
inline void foo (const char*) __attribute__((always_inline));
</pre>

<hr>
<h2><a name="SEC94_asm"><u>Inline Assembler</u></a></h2>
<p>GCC introduces a special <code>asm</code> keyword to support assembler
instructions within C code.  Roughly, its syntax is:</p>
<pre>asm ("<i>instructions</i>" [:<i>output</i>:<i>input</i>]);
</pre>
<p>The <code>asm</code> keyword may appear between usual lines of code or at
the top level, outside of any function body.  <i>instructions</i> may
contain labels and references to global C symbols; in fact, the contents
of the string are copied directly into the output file.</p>

<ul>
<li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC94_simple">Simple Inline Assembler Instructions</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC94">Assembler Instructions with C Expression Operands</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC95">Operand Constraints</a></b>
</li></ul>
<p>If you are writing a header file that should be includable in programs compiled
in GCC's strict ISO C mode, write <code>__asm__</code> instead of <code>asm</code>.
See <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC100">Alternate Keywords</a>.</p>

<h3><a name="SEC94_simple"><u>Simple Inline Assembler Instructions</u></a></h3>
<p>The simplest form the <code>asm</code> keyword is:</p>
<pre>asm ("<i>instructions</i>");
</pre>
<p>where <i>instructions</i> contains one or more assembler instructions
separated by semicolons or newlines.
<br><br>
In GCC4TI, all register names must be preceded by a percent sign, to avoid
confusion with C variables named like one of the CPU registers.  For example:</p>
<pre>asm ("move.l 0xC8,%a0; move.l (%a0,1656),%a0; jsr (%a0)");
</pre>
<p>Hexadecimal constants must be written according to C syntax
(like <code>0xC8</code>), not using the notation <code>$C8</code> which is
common in various assemblers.
<br><br>
Note that something like</p>
<pre>asm ("move.l 0xC8,a0");
</pre>
<p>will be interpreted quite differently: <code>a0</code> will be regarded as a C language
variable, not a register!  Read the documentation about the <a href="https://debrouxl.github.io/gcc4ti/gnuasm.html">GNU Assembler</a>
for more information about the exact syntax and directives which it accepts;
since inline assembler instructions are copied directly into the output of the
compiler, exactly the same features are available.
<br><br>
Newlines as separators are also accepted in <i>instructions</i>, so the following code is valid as well:</p>
<pre>asm ("   move.l 0xC8,%a0
         move.l (%a0,1656),%a0
         jsr (%a0)");
</pre>
<p>See <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC106">Multi-line Strings</a> for more information.</p>

<h3><a name="SEC94"><u>Assembler Instructions with C Expression Operands</u></a></h3>
<p>In an assembler instruction using <code>asm</code>, you can specify the
operands of the instruction using C expressions.  This means you need not
guess which registers or memory locations will contain the data you want
to use.
<br><br>
You must specify an assembler instruction template much like what
appears in a machine description, plus an operand constraint string for
each operand.
<br><br>
For the beginning, you will be given here a very illustrative example on how to use the 68881's
<code>fsinx</code> instruction (note that this example is not applicable to TI calculators,
because the MC68000 processor which is built into the TI-89 and TI-92+ does not have this
instruction, but the example is illustrative anyway):</p>
<pre>asm ("fsinx %1,%0" : "=f" (result) : "f" (angle));
</pre>
<p>Here <i>angle</i> is the C expression for the input operand while
<i>result</i> is that of the output operand.  Each has <code>"f"</code> as its
operand constraint, saying that a floating point register is required.
The <code>=</code> in <code>=f</code> indicates that the operand is an output; all
output operands' constraints must use <code>=</code>.  The constraints use the
same language used in the machine description (see the section <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC95">Operand Constraints</a>).
In this example,
the compiler will convert this instruction into a sequence of assembly instructions
which will ensure that the evaluated expression <i>angle</i> is really stored in
one of the 68881's floating point registers, and which will store the result of the <code>fsinx</code>
(which is in some other floating point register) into the expression <i>result</i>
(note that <i>result</i> need not be a variable; it can be any lvalue expression, for
example a dereferenced pointer).
<br><br>
Each operand is described by an operand-constraint string followed by
the C expression in parentheses.  A colon separates the assembler
template from the first output operand and another separates the last
output operand from the first input, if any.  Commas separate the
operands within each group.  The total number of operands is currently
limited to 30; this limitation may be lifted in some future version of
GCC.
<br><br>
If there are no output operands but there are input operands, you must
place two consecutive colons surrounding the place where the output
operands would go.
<br><br>
As of GCC version 3.1, it is also possible to specify input and output
operands using symbolic names which can be referenced within the
assembler code.  These names are specified inside square brackets
preceding the constraint string, and can be referenced inside the
assembler code using <code>%[<i>name</i>]</code> instead of a percentage sign
followed by the operand number.  Using named operands the above example
could look like:</p>
<pre>asm ("fsinx %[angle],%[output]"
     : [output] "=f" (result)
     : [angle] "f" (angle));
</pre>
<p>Note that the symbolic operand names have no relation whatsoever to
other C identifiers.  You may use any name you like, even those of
existing C symbols, but must ensure that no two operands within the same
assembler construct use the same symbolic name.
<br><br>
Output operand expressions must be lvalues; the compiler can check this.
The input operands need not be lvalues.  The compiler cannot check
whether the operands have data types that are reasonable for the
instruction being executed.  It does not parse the assembler instruction
template and does not know what it means or even whether it is valid
assembler input.  The extended <code>asm</code> feature is most often used for
machine instructions the compiler itself does not know exist.  If
the output expression cannot be directly addressed (for example, it is a
bit-field), your constraint must allow a register.  In that case, GCC
will use the register as the output of the <code>asm</code>, and then store
that register into the output.
<br><br>
Here is an another example, which is applicable to GCC4TI. Suppose that we
want to rotate the value of the expression <i>input</i> one bit to the left, and
to store the result into the expression <i>output</i> (which is an lvalue).
We can write the following code:</p>
<pre>asm ("move.l %1,%%d0; rol #1,%%d0; move.l %%d0,%0" : "=g" (output) : "g" (input));
</pre>
<p>Note that when extended asm constructions are used, the percent sign before the
register names must be doubled. It is important to say that in the above example
<i>input</i> and <i>output</i> may be any valid expressions; in the simple case
when both of them are just global variables, a simple asm construction like</p>
<pre>asm ("move.l input,%d0; rol #1,%d0; move.l %d0,output");
</pre>
<p>would be quite enough. Extended asm constructions allow encapsulating them in macros
which look like functions, like in the following example, which defines a macro <code>'rotate'</code>
which acts like a void function:</p>
<pre>#define rotate(input, output) \
({ asm ("move.l %1,%%d0; rol #1,%%d0; move.l %%d0,%0" \
: "=g" (output) : "g" (input)); })
</pre>
<p>The ordinary output operands must be write-only; GCC will assume that
the values in these operands before the instruction are dead and need
not be generated. That's why the following version of <code>'rotate'</code>
macro which accepts just one argument (and which rotates it one bit to the left)
is quite unreliable:</p>
<pre>#define rotate(inout) ({ asm ("rol #1,%0" : "=d" (inout)); })
</pre>
<p>To solve such difficulties, extended asm supports input-output or read-write
operands.  Use the constraint character <code>+</code> to indicate such an
operand and list it with the output operands.
<br><br>
When the constraints for the read-write operand (or the operand in which
only some of the bits are to be changed) allows a register, you may, as
an alternative, logically split its function into two separate operands,
one input operand and one write-only output operand.  The connection
between them is expressed by constraints which say they need to be in
the same location when the instruction executes.  You can use the same C
expression for both operands, or different expressions.  For example,
here we write the (fictitious) <code>combine</code> instruction with
<code>bar</code> as its read-only source operand and <code>foo</code> as its
read-write destination:</p>
<pre>asm ("combine %2,%0" : "=r" (foo) : "0" (foo), "g" (bar));
</pre>
<p>The constraint <code>"0"</code> for operand 1 says that it must occupy the
same location as operand 0.  A number in constraint is allowed only in
an input operand and it must refer to an output operand.
<br><br>
Only a number in the constraint can guarantee that one operand will be in
the same place as another.  The mere fact that <code>foo</code> is the value
of both operands is not enough to guarantee that they will be in the
same place in the generated assembler code.  The following would not
work reliably:</p>
<pre>asm ("combine %2,%0" : "=r" (foo) : "r" (foo), "g" (bar));
</pre>
<p>Various optimizations or reloading could cause operands 0 and 1 to be in
different registers; GCC knows no reason not to do so.  For example, the
compiler might find a copy of the value of <code>foo</code> in one register and
use it for operand 1, but generate the output operand 0 in a different
register (copying it afterward to <code>foo</code>'s own address).  Of course,
since the register for operand 1 is not even mentioned in the assembler
code, the result will not work, but GCC can't tell that.
<br><br>
As of GCC version 3.1, one may write <code>[<i>name</i>]</code> instead of
the operand number for a matching constraint.  For example:</p>
<pre>asm ("cmoveq %1,%2,%[result]"
     : [result] "=r"(result)
     : "r" (test), "r"(new), "[result]"(old));
</pre>
<p>All the examples given above have a serious drawback: they clobber the register <code>'d0'</code>.
If the compiler keeps something important in it (which is very likely), this may cause lots
of trouble. Of course,
you can save it on the stack at the beginning and restore it at the end, but there is a much better
solution which will save clobbered registers only when necessary. To describe clobbered registers,
write a third colon after the input operands, followed by the names of
the clobbered registers (given as strings), separated by commas:</p>
<pre>#define rotate(input, output) \
({ asm ("move.l %1,%%d0; rol #1,%%d0; move.l %%d0,%0" \
: "=g" (output) : "g" (input) : "d0"); })
</pre>
<p>You may not write a clobber description in a way that overlaps with an
input or output operand.  For example, you may not have an operand
describing a register class with one member if you mention that register
in the clobber list.  Variables declared to live in specific registers
(see <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC97">Explicit Reg Vars</a>), and used as asm input or output operands must
have no part mentioned in the clobber description.
There is no way for you to specify that an input
operand is modified without also specifying it as an output
operand.  Note that if all the output operands you specify are for this
purpose (and hence unused), you will then also need to specify
<code>volatile</code> for the <code>asm</code> construct, as described below, to
prevent GCC from deleting the <code>asm</code> statement as unused.
<br><br>
Whenever you refer to a particular hardware register from the assembler code,
you will probably have to list the register after the third colon to
tell the compiler the register's value is modified.
Alternatively, you can force the compiler to use any data register instead of
<code>'d0'</code>, using the following trick:</p>
<pre>#define rotate(input, output) \
({ register long __temp; \
asm ("move.l %1,%2; rol #1,%2; move.l %2,%0" \
: "=g" (output) : "g" (input), "d" (__temp)); })
</pre>
<p>Here, the <code>"d"</code> constraint ensures that <code>'__temp'</code> will be stored in
the data register (note that <code>rol</code> is applicable only to data registers).
In fact, there is no need for a temporary register if we forced the output to be in
a data register, which can be implemented as in the following example:</p>
<pre>#define rotate(input, output) \
({ asm ("move.l %1,%0; rol #1,%0" : "=d" (output) : "g" (input)); })
</pre>
<p>If your assembler instruction can alter the condition code register, add
<code>cc</code> to the list of clobbered registers.  GCC on some machines
represents the condition codes as a specific hardware register;
<code>cc</code> serves to name this register.  On other machines, the
condition code is handled differently, and specifying <code>cc</code> has no
effect.  But it is valid no matter what the machine.
<br><br>
If your assembler instruction modifies memory in an unpredictable
fashion, add <code>memory</code> to the list of clobbered registers.  This
will cause GCC to not keep memory values cached in registers across
the assembler instruction.  You will also want to add the
<code>volatile</code> keyword if the memory affected is not listed in the
inputs or outputs of the <code>asm</code>, as the <code>memory</code> clobber does
not count as a side-effect of the <code>asm</code>.
<br><br>
As already mentioned above, you can put multiple assembler instructions together in a single
<code>asm</code> template, separated either with newlines or with semicolons
(the GNU assembler allows semicolons as a line-breaking character).
The input operands are guaranteed not to use any of the clobbered
registers, and neither will the output operands' addresses, so you can
read and write the clobbered registers as many times as you like.  Here
is an example of multiple instructions in a template; it assumes the
subroutine <code>_foo</code> accepts arguments in registers a0 and a1:</p>
<pre>asm ("move.l %0,%%a0; move.l %1,%%a1; jsr _foo"
: /* no outputs */
: "g" (from), "g" (to)
: "a0", "a1");
</pre>
<p>Unless an output operand has the <code>'&amp;'</code> constraint modifier, GCC
may allocate it in the same register as an unrelated input operand, on
the assumption the inputs are consumed before the outputs are produced.
This assumption may be false if the assembler code actually consists of
more than one instruction.  In such a case, use <code>'&amp;'</code> for each output
operand that may not overlap an input.  See the section <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC95_cmc">Constraint Modifier Characters</a>.
<br><br>
If you want to test the condition code produced by an assembler
instruction, you must include a branch and a label in the <code>asm</code>
construct, as follows:</p>
<pre>asm ("clr.l %0; test.l %1; beq 0f; moveq #1,%0; 0:"
: "g" (result) : "g" (input));
</pre>
<p>This assumes your assembler supports local labels, which is true for the
<a href="https://debrouxl.github.io/gcc4ti/gnuasm.html">GNU Assembler</a> (it uses the suffix <code>'f'</code> for forward and <code>'b'</code> for
backward local labels; see the section about <a href="https://debrouxl.github.io/gcc4ti/gnuasm.html#SEC48L">Local Symbol Names</a>).<br><br>
Speaking of labels, jumps from one <code>asm</code> to another are not
supported.  The compiler's optimizers do not know about these jumps, and
therefore they cannot take account of them when deciding how to
optimize.
<br><br>
As already mentioned, usually the most convenient way to use these
<code>asm</code> instructions is to encapsulate them in macros that look like
functions. Here is an example of how to define a function-looking macro with
a non-void return type:</p>
<pre>#define rotate(x) \
({ unsigned long __result, __arg=(x);   \
asm ("move.l %1,%0; rol #1,%0": "=d" (__result): "g" (__arg));  \
__result; })
</pre>
<p>This macro acts nearly exactly like a function which takes one <code>unsigned long</code>
argument, and which returns an <code>unsigned long</code> result.
Here the variable <code>__arg</code> is used to make sure that the instruction
operates on a proper <code>unsigned long</code> value, and to accept only those
arguments <code>x</code> which can convert automatically to an <code>unsigned long</code>.
<br><br>
Another way to make sure the instruction operates on the correct data
type is to use a cast in the <code>asm</code>.  This is different from using a
variable <code>__arg</code> in that it converts more different types.  For
example, if the desired type were <code>int</code>, casting the argument to
<code>int</code> would accept a pointer with no complaint, while assigning the
argument to an <code>int</code> variable named <code>__arg</code> would warn about
using a pointer unless the caller explicitly casts it.
<br><br>
If an <code>asm</code> has output operands, GCC assumes for optimization
purposes the instruction has no side effects except to change the output
operands.  This does not mean instructions with a side effect cannot be
used, but you must be careful, because the compiler may eliminate them
if the output operands aren't used, or move them out of loops, or
replace two with one if they constitute a common subexpression.  Also,
if your instruction does have a side effect on a variable that otherwise
appears not to change, the old value of the variable may be reused later
if it happens to be found in a register.
<br><br>
If you are not happy with this behavior,
you can prevent an <code>asm</code> instruction from being deleted, moved
significantly, or combined, by writing the keyword <code>volatile</code> after
the <code>asm</code>.  For example:</p>
<pre>#define get_and_set_priority(new)              \
({ int __old;                                  \
   asm volatile ("get_and_set_priority %0, %1" \
                 : "=g" (__old) : "g" (new));  \
   __old; })
</pre>
<p>If you write an <code>asm</code> instruction with no outputs, GCC will know
the instruction has side-effects and will not delete the instruction or
move it outside of loops.
<br><br>
The <code>volatile</code> keyword indicates that the instruction has
important side-effects.  GCC will not delete a volatile <code>asm</code> if
it is reachable.  (The instruction can still be deleted if GCC can
prove that control-flow will never reach the location of the
instruction.)  In addition, GCC will not reschedule instructions
across a volatile <code>asm</code> instruction.  For example:</p>
<pre>#define inline_rowread(x) \
  ({*(short*)0x600018=(short)(x); \
  asm volatile("nop;nop;nop;nop;nop;nop;nop;nop;nop;nop;nop;nop":::"memory"); \
  ~(*(unsigned char*)0x60001b);})</pre>
<p>Here, we can read the keyboard port at 0x60001b only 12 nops after setting
the keyboard mask at 0x600018. Therefore, we need to make sure that the
nops get scheduled between the write to 0x600018 and the read to 0x60001b.
The <code>volatile</code> keyword makes sure that the instructions get ordered
in the correct way.
<br><br>
Note that even a volatile <code>asm</code> instruction can be moved in ways
that appear insignificant to the compiler, such as across jump
instructions.  You can't expect a sequence of volatile <code>asm</code>
instructions to remain perfectly consecutive.  If you want consecutive
output, use a single <code>asm</code>.  Also, GCC will perform some
optimizations across a volatile <code>asm</code> instruction; GCC does not
"forget everything" when it encounters a volatile <code>asm</code>
instruction the way some other compilers do.
<br><br>
An <code>asm</code> instruction without any operands or clobbers (an "old
style" <code>asm</code>) will be treated identically to a volatile
<code>asm</code> instruction.
<br><br>
It is a natural idea to look for a way to give access to the condition
code left by the assembler instruction.  However, when we attempted to
implement this, we found no way to make it work reliably.  The problem
is that output operands might need reloading, which would result in
additional following "store" instructions.  On most machines, these
instructions would alter the condition code before there was time to
test it.  This problem doesn't arise for ordinary "test" and
"compare" instructions because they don't have any output operands.
<br><br>
For reasons similar to those described above, it is not possible to give
an assembler instruction access to the condition code left by previous
instructions.
<br><br>
You can write write <code>__asm__</code> instead of <code>asm</code>.
See section <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC100">Alternate Keywords</a>.</p>

<h3><a name="SEC95"><u>Operand Constraints</u></a></h3>
<p>Each match operand in an instruction pattern can specify a
constraint for the type of operands allowed.  Constraints can say whether
an operand may be in a register, and which kinds of register; whether the
operand can be a memory reference, and which kinds of address; whether the
operand may be an immediate constant, and which possible values it may
have.  Constraints can also require two operands to match.  Here, only those
operand constraints which are valid for the Motorola 68000 processor and the
built-in inline assembly will be described (i.e. those which are applicable to GCC4TI).</p>

<ul>
<li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC95_simple">Simple Constraints</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC95_cmc">Constraint Modifier Characters</a></b>
</li></ul>
<h4><a name="SEC95_simple"><u>Simple Constraints</u></a></h4>
<p>The simplest kind of constraint is a string full of letters, each of
which describes one kind of operand that is permitted.  These are
the letters that are allowed:</p>
<dl>

<dt><p><code>m</code></p></dt><dd><p>A memory operand is allowed, with any kind of address that the machine
supports in general.
</p></dd><dt><p><code>o</code></p></dt><dd><p>A memory operand is allowed, but only if the address is
<u>offsettable</u>.  This means that adding a small integer (actually,
the width in bytes of the operand, as determined by its machine mode)
may be added to the address and the result is also a valid memory
address.
For example, an address which is constant is offsettable; so is an
address that is the sum of a register and a constant (as long as a
slightly larger constant is also within the range of address-offsets
supported by the machine); but an autoincrement or autodecrement
address is not offsettable.  More complicated indirect/indexed
addresses may or may not be offsettable depending on the other
addressing modes that the machine supports.
<br><br>
Note that in an output operand which can be matched by another
operand, the constraint letter <code>o</code> is valid only when accompanied
by both <code>&lt;</code> (if the target machine has predecrement addressing)
and <code>&gt;</code> (if the target machine has preincrement addressing).
</p></dd><dt><p><code>V</code></p></dt><dd><p>A memory operand that is not offsettable.  In other words, anything that
would fit the <code>m</code> constraint but not the <code>o</code> constraint.
</p></dd><dt><p><code>&lt;</code></p></dt><dd><p>A memory operand with autodecrement addressing is allowed.
</p></dd><dt><p><code>&gt;</code></p></dt><dd><p>A memory operand with autoincrement addressing is allowed.
</p></dd><dt><p><code>r</code></p></dt><dd><p>A register operand is allowed provided that it is in a general
register.
</p></dd><dt><p><code>d</code></p></dt><dd><p>A data register is allowed. This is a Motorola-specific constraint.
</p></dd><dt><p><code>a</code></p></dt><dd><p>An address register is allowed. This is a Motorola-specific constraint.
</p></dd><dt><p><code>f</code></p></dt><dd><p>A 68881 floating-point register is allowed, if available (of course, it is not
available on the TI-89 and TI-92 Plus). This is a Motorola-specific constraint.
</p></dd><dt><p><code>i</code></p></dt><dd><p>An immediate integer operand (one with constant value) is allowed.
This includes symbolic constants whose values will be known only at
assembly time.
</p></dd><dt><p><code>n</code></p></dt><dd><p>An immediate integer operand with a known numeric value is allowed.
Many systems cannot support assembly-time constants for operands less
than a word wide.  Constraints for these operands should use <code>n</code>
rather than <code>i</code>.
</p></dd><dt><p><code>I</code></p></dt><dd><p>An integer in the range 1 to 8 is allowed. This is a Motorola-specific constraint, and this is
for example the range permitted as a shift count in the shift instructions.
</p></dd><dt><p><code>J</code></p></dt><dd><p>A 16 bit signed number is allowed. This is a Motorola-specific constraint.
</p></dd><dt><p><code>K</code></p></dt><dd><p>A signed number whose magnitude is greater than 0x80 is allowed. This is a Motorola-specific constraint.
</p></dd><dt><p><code>L</code></p></dt><dd><p>An integer in the range -8 to -1 is allowed. This is a Motorola-specific constraint.
</p></dd><dt><p><code>M</code></p></dt><dd><p>A signed number whose magnitude is greater than 0x100 is allowed. This is a Motorola-specific constraint.
</p></dd><dt><p><code>s</code></p></dt><dd><p>An immediate integer operand whose value is not an explicit integer is
allowed.
<br><br>
This might appear strange; if an instruction allows a constant operand with a
value not known at compile time, it certainly must allow any known
value.  So why use <code>s</code> instead of <code>i</code>?  Sometimes it allows
better code to be generated.
For example, on the 68000 in a fullword instruction it is possible to
use an immediate operand; but if the immediate value is between -128
and 127, better code results from loading the value into a register and
using the register. This is because the load into the register can be
done with a <code>'moveq'</code> instruction. The GNU team arranges for this to happen
by defining the letter <code>K</code> to mean "any integer outside the
range -128 to 127", and then specifying <code>Ks</code> in the operand
constraints. (This constraint is very unlikely to be useful for inline assembly,
since you cannot use constraints to make GCC choose between 2 different
inline assembly statements.)
</p></dd><dt><p><code>g</code></p></dt><dd><p>Any register, memory or immediate integer operand is allowed, except for
registers that are not general registers.
</p></dd><dt><p><code>X</code></p></dt><dd><p>Any operand whatsoever is allowed, even if it does not satisfy
<code>general_operand</code>.  This is normally used in the constraint of
a <code>match_scratch</code> when certain alternatives will not actually
require a scratch register.
</p></dd><dt><p><code>0</code>, <code>1</code>, <code>2</code>, ... <code>9</code></p></dt><dd><p>An operand that matches the specified operand number is allowed.  If a
digit is used together with letters within the same alternative, the
digit should come last.
This is called a <b>matching constraint</b> and what it really means is
that the assembler has only a single operand that fills two roles
considered separate. More precisely, the two operands that match must
include one input-only operand and one output-only operand.  Moreover, the digit
must be a smaller number than the number of the operand that uses it in the
constraint.
</p></dd><dt><p><code>p</code></p></dt><dd><p>An operand that is a valid memory address is allowed.</p>
</dd></dl>
<p>In order to have valid assembler code, each operand must satisfy
its constraint.  But a failure to do so does not prevent the pattern
from applying to an instruction pattern.  Instead, it directs the compiler to modify
the code so that the constraint will be satisfied.  Usually this is
done by copying an operand into a register.</p>

<h4><a name="SEC95_cmc"><u>Constraint Modifier Characters</u></a></h4>
<p>These are the constraint modifier characters which are meaningful for GCC4TI:</p>
<dl>

<dt><p><code>=</code></p></dt><dd><p>Means that this operand is write-only for this instruction: the previous
value is discarded and replaced by output data.
</p></dd><dt><p><code>+</code></p></dt><dd><p>Means that this operand is both read and written by the instruction.
<br><br>
When the compiler fixes up the operands to satisfy the constraints,
it needs to know which operands are inputs to the instruction and
which are outputs from it.  <code>=</code> identifies an output; <code>+</code>
identifies an operand that is both input and output; all other operands
are assumed to be input only.
<br><br>
If you specify <code>=</code> or <code>+</code> in a constraint, you put it in the
first character of the constraint string.
</p></dd><dt><p><code>&amp;</code></p></dt><dd><p>Means (in a particular alternative) that this operand is an
<b>earlyclobber</b> operand, which is modified before the instruction is
finished using the input operands.  Therefore, this operand may not lie
in a register that is used as an input operand or as part of any memory
address.
<code>&amp;</code> does not obviate the need to write <code>=</code>.</p>
</dd></dl>

<hr>
<h2><a name="SEC96"><u>Controlling Names Used in Assembler Code</u></a></h2>
<p>You can specify the name to be used in the assembler code for a C
function or variable by writing the <code>asm</code> (or <code>__asm__</code>)
keyword after the declarator as follows:</p>
<pre>int foo asm ("myfoo") = 2;
</pre>
<p>This specifies that the name to be used for the variable <code>foo</code> in
the assembler code should be <code>myfoo</code> rather than the usual
<code>foo</code>.
<br><br>
On systems where an underscore is normally prepended to the name of a C
function or variable, this feature allows you to define names for the
linker that do not start with an underscore.
<br><br>
It does not make sense to use this feature with a non-static local
variable since such variables do not have assembler names.  If you are
trying to put the variable in a particular register, see <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC97">Explicit
Reg Vars</a>.  GCC presently accepts such code with a warning, but will
probably be changed to issue an error, rather than a warning, in the
future.
<br><br>
You cannot use <code>asm</code> in this way in a function <i>definition</i>; but
you can get the same effect by writing a <i>declaration</i> for the function
before its definition and putting <code>asm</code> there, like this:</p>
<pre>extern func () asm ("FUNC");

func (int x, int y)
/* ... */
</pre>
<p>It is up to you to make sure that the assembler names you choose do not
conflict with any other assembler symbols.  Also, you must not use a
register name; that would produce completely invalid assembler code.  GCC
does not as yet have the ability to store static variables in registers.
Perhaps that will be added.</p>

<hr>
<h2><a name="SEC97"><u>Variables in Specified Registers</u></a></h2>
<p>GNU C allows you to put a few global variables into specified hardware
registers.  You can also specify the register in which an ordinary
register variable should be allocated.  GCC4TI also allows you to specify
an explicit register for function parameters.</p>

<ul>
<li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC98">Defining Global Register Variables</a></b>
<p>Global register variables reserve registers throughout the program.
This may be useful in programs such as programming language
interpreters which have a couple of global variables that are accessed
very often.</p>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC99">Specifying Registers for Local Variables</a></b>
<p>Local register variables in specific registers do not reserve the
registers.  The compiler's data flow analysis is capable of determining
where the specified registers contain live values, and where they are
available for other uses.  Stores into local register variables may be deleted
when they appear to be dead according to dataflow analysis.  References
to local register variables may be deleted or moved or simplified.</p>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC99a">Specifying Registers for Function Parameters</a></b>
<p>In GCC4TI, it is possible to specify explictly where the parameters to a function
a stored, in a syntax similar to global and local register variables.</p>
</li></ul>
<h3><a name="SEC98"><u>Defining Global Register Variables</u></a></h3>
<p><b>Global register variables reserve registers throughout the program.
This may be useful in programs such as programming language
interpreters which have a couple of global variables that are accessed
very often.</b></p>

<p>You can define a global register variable in GNU C like this:</p>
<pre>register int *foo asm ("a3");
</pre>
<p>Here <code>a3</code> is the name of the register which should be used.  Choose a
register which is normally saved and restored by function calls on your
machine, so that library routines will not clobber it.
<br><br>
Naturally the register name is cpu-dependent, so you would need to
conditionalize your program according to cpu type.  The register
<code>a3</code> would be a good choice on a 68000 for a variable of pointer
type.  On machines with register windows, be sure to choose a "global"
register that is not affected magically by the function call mechanism.
<br><br>
In addition, operating systems on one type of cpu may differ in how they
name the registers; then you would need additional conditionals.  For
example, some 68000 operating systems call this register <code>%a3</code>.
<br><br>
Eventually there may be a way of asking the compiler to choose a register
automatically, but first we need to figure out how it should choose and
how to enable you to guide the choice.  No solution is evident.
<br><br>
Defining a global register variable in a certain register reserves that
register entirely for this use, at least within the current compilation.
The register will not be allocated for any other purpose in the functions
in the current compilation.  The register will not be saved and restored by
these functions.  Stores into this register are never deleted even if they
would appear to be dead, but references may be deleted or moved or
simplified.
<br><br>
It is not safe to access the global register variables from interrupt
handlers, because the system
library routines may temporarily use the register for other things (unless
you recompile them specially for the task at hand).
<br><br>
It is not safe for one function that uses a global register variable to
call another such function <code>foo</code> by way of a third function
<code>lose</code> that was compiled without knowledge of this variable (i.e. in a
different source file in which the variable wasn't declared).  This is
because <code>lose</code> might save the register and put some other value there.
For example, you can't expect a global register variable to be available in
the comparison-function that you pass to <a href="https://debrouxl.github.io/gcc4ti/stdlib.html#qsort">qsort</a>, since it
might have put something else in that register.  (If you are prepared to
recompile it with the same global register variable, you can
solve this problem.)
<br><br>
If you want to recompile <code>qsort</code> or other source files which do not
actually use your global register variable, so that they will not use that
register for any other purpose, then it suffices to specify the compiler
option <b>'-ffixed-<i>reg</i>'</b>.  You need not actually add a global
register declaration to their source code.
<br><br>
A function which can alter the value of a global register variable cannot
safely be called from a function compiled without this variable, because it
could clobber the value the caller expects to find there on return.
Therefore, the function which is the entry point into the part of the
program that uses the global register variable must explicitly save and
restore the value which belongs to its caller.
<br><br>
Be careful if you use <a href="https://debrouxl.github.io/gcc4ti/setjmp.html#longjmp">longjmp</a> with global register
variables, because it will restore to each global register
variable the value it had at the time of the
<a href="https://debrouxl.github.io/gcc4ti/setjmp.html#setjmp">setjmp</a>.
<br><br>
All global register variable declarations must precede all function
definitions.  If such a declaration could appear after function
definitions, the declaration would be too late to prevent the register from
being used for other purposes in the preceding functions.
<br><br>
Global register variables may not have initial values, because an
executable file has no means to supply initial contents for a register.
<br><br>
On the Motorola 68000, <code>a2</code>&nbsp;...&nbsp;<code>a5</code> should be suitable for global register variables,
as should <code>d3</code>&nbsp;...&nbsp;<code>d7</code>.
Of course, it will not do to use more than a few of those.
Note that <code>a5</code> is used by
<code><a href="https://debrouxl.github.io/gcc4ti/httigcc.html#advanced_optrom">OPTIMIZE_ROM_CALLS</a></code>.</p>

<h3><a name="SEC99"><u>Specifying Registers for Local Variables</u></a></h3>
<p><b>Local register variables in specific registers do not reserve the
registers.  The compiler's data flow analysis is capable of determining
where the specified registers contain live values, and where they are
available for other uses.  Stores into local register variables may be deleted
when they appear to be dead according to dataflow analysis.  References
to local register variables may be deleted or moved or simplified.</b></p>

<p>These local variables are sometimes convenient for use with the extended
<code>asm</code> feature (see the section <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC94">Assembler
Instructions with C Expression Operands</a>), if you want to write one
output of the assembler instruction directly into a particular register
(this will work provided the register you specify fits the constraints
specified for that operand in the <code>asm</code> block).
<br><br>
You can define a local register variable with a specified register
like this:</p>
<pre>register int *foo asm ("a5");
</pre>
<p>Here <code>a5</code> is the name of the register which should be used.  Note
that this is the same syntax used for defining global register
variables, but for a local variable it would appear within a function.
<br><br>
Naturally the register name is cpu-dependent, but this is not a
problem, since specific registers are most often useful with explicit
assembler instructions (see the section <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC94">Assembler Instructions with C
Expression Operands</a>), which is CPU-specific as well, and since GCC4TI
only supports exactly one CPU (the Motorola 68000) anyway.
<br><br>
In addition, operating systems on one type of cpu may differ in how they
name the registers; then you would need additional conditionals.  For
example, some 68000 operating systems call this register <code>%a5</code>.
<br><br>
Defining such a register variable does not reserve the register; it
remains available for other uses in places where flow control determines
the variable's value is not live.  However, these registers are made
unavailable for use in the reload pass; excessive use of this feature
leaves the compiler too few available registers to compile certain
functions.
<br><br>
This option does not guarantee that GCC will generate code that has
this variable in the register you specify at all times.  You may not
code an explicit reference to this register in an <code>asm</code> statement
and assume it will always refer to this variable.
<br><br>
Stores into local register variables may be deleted when they appear to be dead
according to dataflow analysis.  References to local register variables may
be deleted or moved or simplified.</p>

<h3><a name="SEC99a"><u>Specifying Registers for Function Parameters</u></a></h3>
<p><b>In GCC4TI, it is possible to specify explictly where the parameters to a function
a stored, in a syntax similar to global and local register variables.</b></p>

<p>GCC4TI can pass function parameters either on the stack or through registers.
You can use the <code><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC85_regparm">regparm</a></code> attribute or the <b>'-mregparm'</b>
compiler switch to let the compiler automatically choose registers for the parameters, but you can
also tell GCC4TI to put a parameter into a specific register.  This can be very handy when
interfacing with assembly code.  For example, the following assembly function expects its 2
parameters in the <code>d1</code> and <code>d2</code> registers:</p>
<pre>asm(".globl add
add:
     move.l %d2,%d0
     add.l %d1,%d0
     rts");
</pre>
<p>Therefore, its prototype would be:</p>
<pre>unsigned long add (unsigned long a asm("d1"), unsigned long b asm("d2"));
</pre>
<p>Explicit register specifications for function parameters are also supported in function headers
(not only in prototypes).  Therefore, the assembly function above could be replaced by the following
C equivalent:</p>
<pre>unsigned long add (unsigned long a asm("d1"), unsigned long b asm("d2"))
{
  return a + b;
}
</pre>
<p>to pass a register parameter.  The registers do not necessarily need to be
call-clobbered.  You can also use a2-a5/d3-d7 to pass a register parameter.
But note that the called function still has to save and restore those registers,
even if they are used as arguments!  In C code, GCC4TI takes care of that
automatically for you, but in assembly code, it is something you need to remember.</p>

<p>See also: <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC85_regparm">regparm</a></p>
<hr>
<h2><a name="SEC100"><u>Alternate Keywords</u></a></h2>
<p><b>'-ansi'</b> and the various <b>'-std'</b> options disable certain
keywords.  This causes trouble when you want to use GNU C extensions, or
a general-purpose header file that should be usable by all programs,
including ISO C programs.  The keywords <code>asm</code>, <code>typeof</code> and
<code>inline</code> are not available in programs compiled with
<b>'-ansi'</b> or <b>'-std'</b> (although <code>inline</code> can be used in a
program compiled with <b>'-std=c99'</b>).  The ISO C99 keyword
<code>restrict</code> is only available when <b>'-std=gnu99'</b> (which will
eventually be the default) or <b>'-std=c99'</b> (or the equivalent
<b>'-std=iso9899:1999'</b>) is used.
<br><br>
The way to solve these problems is to put <code>__</code> at the beginning and
end of each problematical keyword.  For example, use <code>__asm__</code>
instead of <code>asm</code>, and <code>__inline__</code> instead of <code>inline</code>.
<br><br>
Other C compilers won't accept these alternative keywords; if you want to
compile with another compiler, you can define the alternate keywords as
macros to replace them with the customary keywords.  It looks like this:</p>
<pre>#ifndef __GNUC__
#define __asm__ asm
#endif
</pre>
<p><b>'-pedantic'</b> and other options cause warnings for many GNU C extensions.
You can
prevent such warnings within one expression by writing
<code>__extension__</code> before the expression.  <code>__extension__</code> has no
effect aside from this.</p>

<hr>
<h2><a name="SEC101"><u>Incomplete 'enum' Types</u></a></h2>
<p>You can define an <code>enum</code> tag without specifying its possible values.
This results in an incomplete type, much like what you get if you write
<code>struct&nbsp;foo</code> without describing the elements.  A later declaration
which does specify the possible values completes the type.
<br><br>
You can't allocate variables or storage using the type while it is
incomplete.  However, you can work with pointers to that type.
<br><br>
This extension may not be very useful, but it makes the handling of
<code>enum</code> more consistent with the way <code>struct</code> and <code>union</code>
are handled.</p>

<hr>
<h2><a name="SEC102"><u>Function Names as Strings</u></a></h2>
<p>GCC predefines two magic identifiers to hold the name of the current
function.  The identifier <code>__FUNCTION__</code> holds the name of the function
as it appears in the source.  The identifier <code>__PRETTY_FUNCTION__</code>
holds the name of the function pretty printed in a language specific
fashion.
(These names are always the same in a C function, but in a C++ function
they may be different; don't care about this, because GCC4TI is not a C++ compiler.)
<br><br>
The compiler automatically replaces the identifiers with a string
literal containing the appropriate name.  Thus, they are neither
preprocessor macros, like <code>__FILE__</code> and <code>__LINE__</code>, nor
variables.  This means that they catenate with other string literals, and
that they can be used to initialize char arrays.  For example</p>
<pre>char here[] = "Function " __FUNCTION__ " in " __FILE__;
</pre>
<p>On the other hand, <code>#ifdef&nbsp;__FUNCTION__</code> does not have any special
meaning inside a function, since the preprocessor does not do anything
special with the identifier <code>__FUNCTION__</code>.
<br><br>
Note that these semantics are deprecated, and that GCC 3.2 will handle
<code>__FUNCTION__</code> and <code>__PRETTY_FUNCTION__</code> the same way as
<code>__func__</code>.  <code>__func__</code> is defined by the ISO standard C99:
<br><br>
The identifier <code>__func__</code> is implicitly declared by the translator
as if, immediately following the opening brace of each function
definition, the declaration</p>
<pre>static const char __func__[] = "function-name";
</pre>
<p>appeared, where function-name is the name of the lexically-enclosing
function.  This name is the unadorned name of the function.
<br><br>
By this definition, <code>__func__</code> is a variable, not a string literal.
In particular, <code>__func__</code> does not catenate with other string
literals.</p>

<hr>
<h2><a name="SEC103"><u>Getting the Return or Frame Address of a Function</u></a></h2>
<p>These functions may be used to get information about the callers of a
function.</p>

<ul>
<li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC103___builtin_return_address">__builtin_return_address</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC103___builtin_frame_address">__builtin_frame_address</a></b>
</li></ul>
<h3><a name="SEC103___builtin_return_address"><u>__builtin_return_address</u></a></h3>
<p><code><b><a href="https://debrouxl.github.io/gcc4ti/keywords.html#void">void</a></b> *__builtin_return_address (<b><a href="https://debrouxl.github.io/gcc4ti/keywords.html#int">int</a></b> level);</code>
<br><br>
This function returns the return address of the current function, or of
one of its callers.  The <i>level</i> argument is number of frames to
scan up the call stack.  A value of <code>0</code> yields the return address
of the current function, a value of <code>1</code> yields the return address
of the caller of the current function, and so forth. When inlining
the expected behavior is that the function will return the address of
the function that will be returned to.  To work around this behavior use
the <code>noinline</code> function attribute.
<br><br>
The <i>level</i> argument must be a constant integer.
<br><br>
Sometimes (especially without a frame pointer)
it may be impossible to determine the return address of
any function other than the current one; in such cases, or when the top
of the stack has been reached, this function will return a
random value.  In addition, <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC103___builtin_frame_address">__builtin_frame_address</a> may be used
to determine if the top of the stack has been reached.
<br><br>
This function should be used with a nonzero argument only for debugging
purposes.</p>

<h3><a name="SEC103___builtin_frame_address"><u>__builtin_frame_address</u></a></h3>
<p><code><b><a href="https://debrouxl.github.io/gcc4ti/keywords.html#void">void</a></b> *__builtin_frame_address (<b><a href="https://debrouxl.github.io/gcc4ti/keywords.html#int">int</a></b> level);</code>
<br><br>
This function is similar to <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC103___builtin_return_address">__builtin_return_address</a>, but it
returns the address of the function frame rather than the return address
of the function.  Calling __builtin_frame_address with a value of
0 yields the frame address of the current function, a value of
1 yields the frame address of the caller of the current function,
and so forth.
<br><br>
The frame is the area on the stack which holds local variables and saved
registers.  The frame address is normally the address of the first word
pushed on to the stack by the function.  However, the exact definition
depends upon the processor and the calling convention.  On the Motorola
68000, if the function has a frame,
then __builtin_frame_address will return the value of the frame
pointer register <code>a6</code> if <i>level</i> is 0.
<br><br>
This function should be used with a nonzero argument only for debugging
purposes.</p>

<hr>
<h2><a name="SEC104"><u>Other built-in functions provided by GCC</u></a></h2>
<p>GCC provides a large number of built-in functions.  Some of these are for internal use in the processing
of exceptions or variable-length argument lists and will not be
documented here because they may change from time to time; we do not
recommend general use of these functions.
<br><br>
The remaining functions are provided for optimization purposes.</p>

<ul>
<li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC104___builtin_constant_p">__builtin_constant_p</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC104___builtin_types_compatible_p">__builtin_types_compatible_p</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC104___builtin_choose_expr">__builtin_choose_expr</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC104___builtin_expect">__builtin_expect</a></b>
</li><li><b><a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC104___builtin_prefetch">__builtin_prefetch</a></b>
</li></ul>
<p>GCC includes built-in versions of many of the functions in the standard
C library.  The versions prefixed with <code>__builtin_</code> will always be
treated as having the same meaning as the C library function even if you
specify the <b>'-fno-builtin'</b> option (see <a href="https://debrouxl.github.io/gcc4ti/comopts.html#SEC6">C Dialect Options</a>).
Many of these functions are only optimized in certain cases; if they are
not optimized in a particular case, a call to the library function will
be emitted
(but this does not make sense in GCC4TI, as the standard C library is not provided with it).
<br><br>
The functions <code>abort</code>, <code>exit</code>, <code>_Exit</code> and <code>_exit</code>
are recognized and presumed not to return, but otherwise are not built
in (GCC4TI defines them as macros anyway).  <code>_exit</code> is not recognized in strict ISO C mode (<b>'-ansi'</b>,
<b>'-std=c89'</b> or <b>'-std=c99'</b>).  <code>_Exit</code> is not recognized in
strict C89 mode (<b>'-ansi'</b> or <b>'-std=c89'</b>).  All these functions
have corresponding versions prefixed with <code>__builtin_</code>, which may be
used even in strict C89 mode.
<br><br>
Outside strict ISO C mode, the functions <code>alloca</code>, <code>bcmp</code>,
<code>bzero</code>, <code>index</code>, <code>rindex</code>, <code>ffs</code>, <code>fputs_unlocked</code>,
<code>printf_unlocked</code> and <code>fprintf_unlocked</code> may be handled as
built-in functions.  All these functions have corresponding versions
prefixed with <code>__builtin_</code>, which may be used even in strict C89
mode
(in GCC4TI, <a href="https://debrouxl.github.io/gcc4ti/alloc.html#alloca">alloca</a> is built-in;
other than that only <code>__builtin_bzero</code> might be useful).
<br><br>
The ISO C99 functions <code>conj</code>, <code>conjf</code>, <code>conjl</code>,
<code>creal</code>, <code>crealf</code>, <code>creall</code>, <code>cimag</code>, <code>cimagf</code>,
<code>cimagl</code>, <code>imaxabs</code>, <code>llabs</code>, <code>snprintf</code>,
<code>vscanf</code>, <code>vsnprintf</code> and <code>vsscanf</code> are handled as built-in
functions except in strict ISO C90 mode.  There are also built-in
versions of the ISO C99 functions <code>cosf</code>, <code>cosl</code>,
<code>expf</code>, <code>expl</code>, <code>fabsf</code>, <code>fabsl</code>,
<code>logf</code>, <code>logl</code>, <code>sinf</code>, <code>sinl</code>, <code>sqrtf</code>, and
<code>sqrtl</code>, that are recognized in any mode since ISO C90 reserves
these names for the purpose to which ISO C99 puts them.  All these
functions have corresponding versions prefixed with <code>__builtin_</code>
(again, none of these are implemented in GCC4TI).
<br><br>
The ISO C90 functions <code>abs</code>, <code>cos</code>, <code>exp</code>, <code>fabs</code>,
<code>fprintf</code>, <code>fputs</code>, <code>labs</code>, <code>log</code>,
<code>memcmp</code>, <code>memcpy</code>,
<code>memset</code>, <code>printf</code>, <code>putchar</code>, <code>puts</code>, <code>scanf</code>,
<code>sin</code>, <code>snprintf</code>, <code>sprintf</code>, <code>sqrt</code>, <code>sscanf</code>,
<code>strcat</code>,
<code>strchr</code>, <code>strcmp</code>, <code>strcpy</code>, <code>strcspn</code>,
<code>strlen</code>, <code>strncat</code>, <code>strncmp</code>, <code>strncpy</code>,
<code>strpbrk</code>, <code>strrchr</code>, <code>strspn</code>, <code>strstr</code>,
<code>vprintf</code> and <code>vsprintf</code> are all
recognized as built-in functions unless <b>'-fno-builtin'</b> is
specified (or <b>'-fno-builtin-<i>function</i>'</b> is specified for an
individual function).  All of these functions have corresponding
versions prefixed with <code>__builtin_</code>
(but most of these are defined as macros in GCC4TI).
<br><br>
GCC provides built-in versions of the ISO C99 floating point comparison
macros that avoid raising exceptions for unordered operands.  They have
the same names as the standard macros (<code>isgreater</code>,
<code>isgreaterequal</code>, <code>isless</code>, <code>islessequal</code>,
<code>islessgreater</code>, and <code>isunordered</code>), with <code>__builtin_</code>
prefixed.  The GNU team intends for a library implementor to be able to simply
<code>#define</code> each standard macro to its built-in equivalent.</p>

<h3><a name="SEC104___builtin_constant_p"><u>__builtin_constant_p</u></a></h3>
<p><code><b><a href="https://debrouxl.github.io/gcc4ti/keywords.html#int">int</a></b> __builtin_constant_p (exp);</code>
<br><br>
You can use the built-in function <code>__builtin_constant_p</code> to
determine if a value is known to be constant at compile-time and hence
that GCC can perform constant-folding on expressions involving that
value.  The argument of the function is the value to test.  The function
returns the integer 1 if the argument is known to be a compile-time
constant and 0 if it is not known to be a compile-time constant.  A
return of 0 does not indicate that the value is <i>not</i> a constant,
but merely that GCC cannot prove it is a constant with the specified
value of the <b>'-O'</b> option.
<br><br>
If you have some complex calculation,
you may want it to be folded if it involves constants, but need to call
a function if it does not.  For example:</p>
<pre>#define Scale_Value(X)      \
  (__builtin_constant_p (X) \
  ? ((X) * SCALE + OFFSET) : Scale (X))
</pre>
<p>You may use this built-in function in either a macro or an inline
function.  However, if you use it in an inlined function and pass an
argument of the function as the argument to the built-in, GCC will
never return 1 when you call the inline function with a string constant
or compound literal (see <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html#SEC81">Compound Literals</a>) and will not return 1
when you pass a constant numeric value to the inline function unless you
specify the <b>'-O'</b> option.
<br><br>
You may also use <code>__builtin_constant_p</code> in initializers for static
data.  For instance, you can write</p>
<pre>static const int table[] = {
   __builtin_constant_p (EXPRESSION) ? (EXPRESSION) : -1,
   /* ... */
};
</pre>
<p>This is an acceptable initializer even if <i>EXPRESSION</i> is not a
constant expression.  GCC must be more conservative about evaluating the
built-in in this case, because it has no opportunity to perform
optimization.
<br><br>
Previous versions of GCC did not accept this built-in in data
initializers.  The earliest version where it is completely safe is
3.0.1.</p>

<h3><a name="SEC104___builtin_types_compatible_p"><u>__builtin_types_compatible_p</u></a></h3>
<p><code><b><a href="https://debrouxl.github.io/gcc4ti/keywords.html#int">int</a></b> __builtin_types_compatible_p (type1, type2);</code>
<br><br>
You can use the built-in function __builtin_types_compatible_p to
determine whether two types are the same.
<br><br>
This built-in function returns 1 if the unqualified versions of the
types <i>type1</i> and <i>type2</i> (which are types, not expressions) are
compatible, 0 otherwise.  The result of this built-in function can be
used in integer constant expressions.
<br><br>
This built-in function ignores top level qualifiers (<code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#const">const</a></code>,
<code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#volatile">volatile</a></code>, etc.).  For example, <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#int">int</a></code> is equivalent to <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#const">const</a>
<a href="https://debrouxl.github.io/gcc4ti/keywords.html#int">int</a></code>.
<br><br>
The type <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#int">int</a>[]</code> and <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#int">int</a>[5]</code> are compatible.  On the other
hand, <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#short">long</a>&nbsp;<a href="https://debrouxl.github.io/gcc4ti/keywords.html#int">int</a></code> and <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#int">char</a>*</code> are not compatible,
although their sizes are the same.  Also, the
amount of pointer indirection is taken into account when determining
similarity.  Consequently, <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#short">short</a>*</code> is not similar to
<code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#short">short</a>**</code>.  Furthermore, two types that are typedefed are
considered compatible if their underlying types are compatible.
<br><br>
An <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#enum">enum</a></code> type is considered to be compatible with another
<code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#enum">enum</a></code> type.  For example, <code>enum&nbsp;{foo,&nbsp;bar}</code> is similar to
<code>enum&nbsp;{hot,&nbsp;dog}</code>.
<br><br>
You would typically use this function in code whose execution varies
depending on the arguments' types.  For example:</p>
<pre>#define foo(x)                                                  \
  ({                                                            \
    typeof (x) tmp;                                             \
    if (__builtin_types_compatible_p (typeof (x), long double)) \
      tmp = foo_long_double (tmp);                              \
    else if (__builtin_types_compatible_p (typeof (x), double)) \
      tmp = foo_double (tmp);                                   \
    else if (__builtin_types_compatible_p (typeof (x), float))  \
      tmp = foo_float (tmp);                                    \
    else                                                        \
      abort ();                                                 \
    tmp;                                                        \
  })
</pre>

<h3><a name="SEC104___builtin_choose_expr"><u>__builtin_choose_expr</u></a></h3>
<p><code><i>type</i> __builtin_choose_expr (const_exp, exp1, exp2);</code>
<br><br>
You can use the built-in function __builtin_choose_expr to
evaluate code depending on the value of a constant expression.  This
built-in function returns <i>exp1</i> if <i>const_exp</i>, which is a
constant expression that must be able to be determined at compile time,
is nonzero.  Otherwise it returns 0.
<br><br>
This built-in function is analogous to the <code>?&nbsp;:</code> operator in C,
except that the expression returned has its type unaltered by promotion
rules.  Also, the built-in function does not evaluate the expression
that was not chosen.  For example, if <i>const_exp</i> evaluates to true,
<i>exp2</i> is not evaluated even if it has side-effects.
<br><br>
This built-in function can return an lvalue if the chosen argument is an
lvalue.
<br><br>
If <i>exp1</i> is returned, the return type is the same as <i>exp1</i>'s
type.  Similarly, if <i>exp2</i> is returned, its return type is the same
as <i>exp2</i>.
<br><br>
Example:</p>
<pre>#define foo(x)                                                    \
  __builtin_choose_expr (                                         \
    __builtin_types_compatible_p (typeof (x), double),            \
    foo_double (x),                                               \
    __builtin_choose_expr (                                       \
      __builtin_types_compatible_p (typeof (x), float),           \
      foo_float (x),                                              \
      /* The void expression results in a compile-time error  \
         when assigning the result to something.  */          \
      (void)0))
</pre>
<p><b>Note:</b> The
unused expression (<i>exp1</i> or <i>exp2</i> depending on the value of
<i>const_exp</i>) may still generate syntax errors.  This may change in
future revisions.</p>

<h3><a name="SEC104___builtin_expect"><u>__builtin_expect</u></a></h3>
<p><code><b><a href="https://debrouxl.github.io/gcc4ti/keywords.html#short">long</a></b> __builtin_expect (<b><a href="https://debrouxl.github.io/gcc4ti/keywords.html#short">long</a></b> exp, <b><a href="https://debrouxl.github.io/gcc4ti/keywords.html#short">long</a></b> c);</code>
<br><br>
You may use <code>__builtin_expect</code> to provide the compiler with
branch prediction information.
<br><br>
The return value is the value of <i>exp</i>, which should be an
integral expression.  The value of <i>c</i> must be a compile-time
constant.  The semantics of the built-in are that it is expected
that <i>exp</i> == <i>c</i>.  For example:</p>
<pre>if (__builtin_expect (x, 0))
  foo ();
</pre>
<p>would indicate that we do not expect to call <code>foo</code>, since
we expect <code>x</code> to be zero.  Since you are limited to integral
expressions for <i>exp</i>, you should use constructions such as</p>
<pre>if (__builtin_expect (ptr != NULL, 1))
  error ();
</pre>
<p>when testing pointer or floating-point values.</p>

<h3><a name="SEC104___builtin_prefetch"><u>__builtin_prefetch</u></a></h3>
<p><code><b><a href="https://debrouxl.github.io/gcc4ti/keywords.html#void">void</a></b> __builtin_prefetch (<b><a href="https://debrouxl.github.io/gcc4ti/keywords.html#const">const</a></b> <b><a href="https://debrouxl.github.io/gcc4ti/keywords.html#void">void</a></b> *addr, ...);</code>
<br><br>
This function is used to minimize cache-miss latency by moving data into
a cache before it is accessed.
As the Motorola 68000 processor does not have any data prefetch instruction,
this function is not useful in GCC4TI.</p>

<hr>
<h2><a name="SEC105"><u>Slightly Looser Rules for Escaped Newlines</u></a></h2>
<p>Recently, the preprocessor has relaxed its treatment of escaped
newlines.  Previously, the newline had to immediately follow a
backslash.  The current implementation allows whitespace in the form of
spaces, horizontal and vertical tabs, and form feeds between the
backslash and the subsequent newline.  The preprocessor issues a
warning, but treats it as a valid escaped newline and combines the two
lines to form a single logical line.  This works within comments and
tokens, including multi-line strings, as well as between tokens.
Comments are <i>not</i> treated as whitespace for the purposes of this
relaxation, since they have not yet been replaced with spaces.</p>

<hr>
<h2><a name="SEC106"><u>String Literals with Embedded Newlines</u></a></h2>
<p>As an extension, GNU CPP permits string literals to cross multiple lines
without escaping the embedded newlines.  Each embedded newline is
replaced with a single <code>\n</code> character in the resulting string
literal, regardless of what form the newline took originally.
<br><br>
CPP currently allows such strings in directives as well (other than the
<code>#include</code> family).</p>

<hr>
<h2><a name="SEC107"><u>Mixed Declarations and Code</u></a></h2>
<p>ISO C99 and ISO C++ allow declarations and code to be freely mixed
within compound statements.  As an extension, GCC also allows this in
C89 mode.  For example, you could do:</p>
<pre>int i;
/* ... */
i++;
int j = i + 2;
</pre>
<p>Each identifier is visible from where it is declared until the end of
the enclosing block.</p>

<hr>
<h2><a name="SEC108"><u>Unnamed struct/union Fields within structs/unions</u></a></h2>
<p>For compatibility with other compilers, GCC allows you to define
a structure or union that contains, as fields, structures and unions
without names.  For example:</p>
<pre>struct {
  int a;
  union {
    int b;
    float c;
  };
  int d;
} foo;
</pre>
<p>In this example, the user would be able to access members of the unnamed
union with code like <code>foo.b</code>.  Note that only unnamed structs and
unions are allowed, you may not have, for example, an unnamed
<code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#int">int</a></code>.
<br><br>
You must never create such structures that cause ambiguous field definitions.
For example, this structure:</p>
<pre>struct {
  int a;
  struct {
    int a;
  };
} foo;
</pre>
<p>It is ambiguous which <i>a</i> is being referred to with <code>foo.a</code>.
Such constructs are not supported and must be avoided.  In the future,
such constructs may be detected and treated as compilation errors.</p>

<hr>
<h2><a name="SEC109"><u>Definite Access of Volatile Objects</u></a></h2>
<p>Both the C and C++ standard have the concept of <a href="https://debrouxl.github.io/gcc4ti/keywords.html#volatile">volatile</a> objects.  These
are normally accessed by pointers and used for accessing hardware.  The
standards encourage compilers to refrain from optimizations
concerning accesses to volatile objects that it might perform on
non-volatile objects.  The C standard leaves it implementation defined
as to what constitutes a volatile access.  The C++ standard omits to
specify this, except to say that C++ should behave in a similar manner
to C with respect to volatiles, where possible.  The minimum either
standard specifies is that at a sequence point all previous accesses to
volatile objects have stabilized and no subsequent accesses have
occurred.  Thus an implementation is free to reorder and combine
volatile accesses which occur between sequence points, but cannot do so
for accesses across a sequence point.  The use of volatiles does not
allow you to violate the restriction on updating objects multiple times
within a sequence point.
<br><br>
In most expressions, it is intuitively obvious what is a read and what is
a write.  For instance</p>
<pre>volatile int *dst = <i>somevalue</i>;
volatile int *src = <i>someothervalue</i>;
*dst = *src;
</pre>
<p>will cause a read of the volatile object pointed to by <i>src</i> and stores the
value into the volatile object pointed to by <i>dst</i>.  There is no
guarantee that these reads and writes are atomic, especially for objects
larger than <code><a href="https://debrouxl.github.io/gcc4ti/keywords.html#int">int</a></code>.
<br><br>
Less obvious expressions are where something which looks like an access
is used in a void context.  An example would be,</p>
<pre>volatile int *src = <i>somevalue</i>;
*src;
</pre>
<p>With C, such expressions are rvalues, and as rvalues cause a read of
the object, GCC interprets this as a read of the volatile being pointed
to.</p>

<hr>
<h2><a name="history"><u>History</u></a></h2>
<ul>
<li><p><b>Original Version:</b> <a href="http://gcc.gnu.org/onlinedocs/gcc/C-Extensions.html">Extensions to the C Language Family</a>
<br><br>
Published by the Free Software Foundation
<br>
59 Temple Place - Suite 330
<br>
Boston, MA 02111-1307 USA
<br><br>
Copyright © 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
2000, 2001, 2002 Free Software Foundation, Inc.
</p></li>
<li><p><b>Modifications for TIGCC:</b> <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html">GNU C Language Extensions</a>
<br><br>
Published by the TIGCC Team
<br><br>
Copyright © 2000, 2001, 2002 Zeljko Juric, Sebastian Reichelt, Kevin Kofler</p></li>
<li><p><b>Modifications for GCC4TI:</b> <a href="https://debrouxl.github.io/gcc4ti/gnuexts.html">GNU C Language Extensions</a>
<br><br>

Published by the GCC4TI Project

<br><br>

Copyright © 2009, 2010 Lionel Debroux
</p></li>

</ul>

<hr>
<h3><a href="https://debrouxl.github.io/gcc4ti/index.html">Return to the main index</a></h3>


</body></html>